Bagaimana untuk menggunakan pemprosesan audio dalam Go?

Dengan populariti pemprosesan audio dalam pelbagai senario aplikasi, semakin ramai pengaturcara mula menggunakan Pergi untuk menulis program pemprosesan audio. Sebagai bahasa pengaturcaraan moden, bahasa Go mempunyai konkurensi yang sangat baik dan ciri kecekapan tinggi. Ia sangat mudah untuk digunakan untuk pemprosesan audio. Artikel ini akan memperkenalkan cara menggunakan teknologi pemprosesan audio dalam Go, termasuk membaca, menulis, memproses dan menganalisis data audio.

1. Membaca data audio

Terdapat banyak cara untuk membaca data audio dalam Go. Salah satu yang lebih biasa digunakan ialah menggunakan perpustakaan pihak ketiga untuk membaca, seperti go-sox dan go-wave. Berikut mengambil perpustakaan go-sox sebagai contoh untuk memperkenalkan cara membaca data audio dalam Go.

Mula-mula anda perlu memasang perpustakaan go-sox. Ia boleh dipasang menggunakan arahan berikut:

go get github.com/krig/go-sox

Seterusnya, kod berikut boleh digunakan untuk membaca fail wav:

package main

import (
    "log"

    "github.com/krig/go-sox"
)

func main() {
    // Open the input file
    input, err := sox.OpenRead("input_file.wav")
    if err != nil {
        log.Fatalf("Failed to open input file: %v", err)
    }
    defer input.Release()

    // Read the input file into a buffer
    buffer, err := input.Read(nil)
    if err != nil {
        log.Fatalf("Failed to read input file: %v", err)
    }
}

Dalam contoh ini, fungsi OpenRead membuka fail wav dan Gunakannya sebagai fail input, dan jika ralat berlaku, mesej ralat yang sepadan akan dikembalikan. ReadFungsi membaca data fail audio, dan data yang dibaca dikembalikan dalam bentuk penimbal.

2. Menulis data audio

Sama seperti membaca data audio, anda juga boleh menggunakan beberapa perpustakaan pihak ketiga untuk menulis data audio dalam Go. Sebagai contoh, pustaka go-wave boleh membaca dan menulis fail wav dengan mudah. Berikut mengambil pustaka go-wave sebagai contoh untuk memperkenalkan cara menulis data audio dalam Go.

Mula-mula anda perlu memasang perpustakaan go-wave. Ia boleh dipasang menggunakan arahan berikut:

go get github.com/gerow/go-wave

Seterusnya, data audio boleh ditulis ke fail wav menggunakan kod berikut:

package main

import (
    "log"

    "github.com/gerow/go-wave"
)

func main() {
    // Create a wave file
    w, err := wave.Create("output_file.wav")
    if err != nil {
        log.Fatalf("Failed to create output file: %v", err)
    }
    defer w.Close()

    // Get the audio format
    format := wave.Format{
        Channels:      1,
        SampleRate:    44100,
        SignificantBits: 16,
        ByteRate:      88200,
        BlockAlign:    2,
    }

    // Set the audio format
    err = w.SetFormat(format)
    if err != nil {
        log.Fatalf("Failed to set format: %v", err)
    }

    // Write the audio data
    data := make([]byte, 1024)
    for i := range data {
        data[i] = 0xff
    }
    _, err = w.Write(data)
    if err != nil {
        log.Fatalf("Failed to write audio data: %v", err)
    }
}

Dalam contoh ini, kami menggunakan Create berfungsi untuk mencipta fail wav dan menetapkannya sebagai fail output Jika terdapat ralat, mesej ralat yang sepadan akan dikembalikan. Gunakan fungsi SetFormat untuk menetapkan format audio. Gunakan fungsi Write untuk menulis data audio.

3. Memproses data audio

Untuk pemprosesan data audio, bahasa Go menyediakan banyak perpustakaan, seperti go-portaudio dan goaudio. Mari kita ambil pustaka goaudio sebagai contoh untuk memperkenalkan cara memproses data audio dalam Go.

Mula-mula anda perlu memasang pustaka goaudio. Ia boleh dipasang menggunakan arahan berikut:

go get github.com/cryptix/goaudio

Seterusnya, data audio boleh diproses menggunakan kod berikut:

package main

import (
    "fmt"
    "math"

    "github.com/cryptix/goaudio/snd"
    "github.com/cryptix/goaudio/sndfile"
)

func main() {
    filename := "input_file.wav"

    // Open the file for reading
    sf, err := sndfile.Open(filename, sndfile.Read, nil)
    if err != nil {
        panic(err)
    }
    defer sf.Close()

    // Get the number of frames and channels
    frameCount := sf.Samples
    channelCount := sf.Channels

    // Create a buffer to hold the samples
    buffer := make([]float64, frameCount*channelCount)

    // Read the samples into the buffer
    if err := snd.ReadInto(sf, buffer); err != nil {
        panic(err)
    }

    // Apply a sine wave to the samples
    for i := 0; i < len(buffer); i += channelCount {
        sample := buffer[i]
        angle := float64(i) * 2.0 * math.Pi / float64(sf.SampleRate)
        buffer[i] = sample * math.Sin(angle)
    }

    // Create a new file for writing
    newFilename := "output_file.wav"
    newSf, err := sndfile.Open(newFilename, sndfile.Write, &sf.Info)
    if err != nil {
        panic(err)
    }
    defer newSf.Close()

    // Write the modified samples
    if err := snd.Write(newSf, buffer); err != nil {
        panic(err)
    }

    fmt.Printf("Done")
}

Dalam contoh ini, kami membuka fail wav dan membacanya ke dalam penampan. Kemudian proses mudah dilakukan pada sampel dalam penimbal: gelombang sinus digunakan pada data audio. Selepas itu, kami menulis data audio yang diproses ke dalam fail wav baharu.

4. Menganalisis data audio

Terdapat banyak perpustakaan untuk analisis audio dalam bahasa Go, seperti go-dsp dan gonum. Berikut ialah pengenalan menggunakan perpustakaan go-dsp.

Mula-mula anda perlu memasang perpustakaan go-dsp. Anda boleh memasangnya menggunakan arahan berikut:

go get github.com/mjibson/go-dsp

Seterusnya, anda boleh menggunakan kod berikut untuk mendapatkan data rakaman audio dan menganalisisnya:

package main

import (
    "fmt"
    "os"
    "time"

    "github.com/Twister915/go-dsp/wavio"
)

func main() {
    filename := "recording.wav"

    // Open the wave file
    f, err := os.Open(filename)
    if err != nil {
        panic(err)
    }
    defer f.Close()

    // Parse the wave file
    w, err := wavio.Read(f)
    if err != nil {
        panic(err)
    }

    // Print the sample rate, duration, and length of the data
    fmt.Printf("Sample rate: %d
Duration: %s
Data length: %d
", 
                w.Original.SampleRate, 
                time.Duration(float64(w.Len()) / float64(w.Original.ByteRate) * float64(time.Second)), 
                w.Len())

    // Analyze the data
    var sum float64
    var max float64
    for _, s := range w.Data {
        sum += float64(s)
        if float64(s) > max {
            max = float64(s)
        }
    }

    average := sum / float64(len(w.Data))

    fmt.Printf("Peak amplitude: %f
", max)
    fmt.Printf("Average amplitude: %f
", average)
}

Dalam contoh ini, kami membuka fail A wav dan menganalisis data sampel. Nilai maksimum dan purata data audio dikira masing-masing. Proses ini boleh membantu kami lebih memahami data audio yang sedang kami proses supaya kami boleh merumuskan strategi pemprosesan yang sepadan.

Ringkasan

Artikel ini terutamanya memperkenalkan cara menggunakan teknologi pemprosesan audio dalam Go, termasuk membaca, menulis, memproses dan menganalisis data audio. Pemprosesan audio adalah bidang yang luas, dan artikel ini hanya merangkumi beberapa teknik asas. Dengan pengetahuan asas ini, pembaca boleh mempunyai pemahaman yang mendalam tentang teknologi pemprosesan audio yang lebih kompleks dan membangunkan serta melaksanakannya dalam bahasa Go.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan pemprosesan audio dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!