Verwendung der Go-Sprache für die Audio- und Videoverarbeitung und die Entwicklung von Streaming-Medien

So verwenden Sie die Go-Sprache für die Audio- und Videoverarbeitung und die Entwicklung von Streaming-Medien

Einführung:
Mit der rasanten Entwicklung des Internets und der kontinuierlichen Verbesserung der Netzwerkbandbreite wird die Anwendung von Audio und Video immer weiter verbreitet. Als Programmiersprache mit hoher Parallelität und hoher Leistung hat die Go-Sprache nach und nach die Aufmerksamkeit von Entwicklern auf sich gezogen. In diesem Artikel wird die Verwendung der Go-Sprache für die Audio- und Videoverarbeitung und die Entwicklung von Streaming-Medien vorgestellt, einschließlich der folgenden Themen: Verarbeitung von Audio- und Videoformaten, Kodierung und Dekodierung von Audio- und Videos, Übertragung und Streaming von Audio- und Videos, Aufbau von Streaming-Medienservern usw .

1. Verarbeitung von Audio- und Videoformaten
Bei der Audio- und Videoverarbeitung gehören zu den gängigen Audio- und Videoformaten MP3, AAC, WAV, FLV, MP4 usw. Die Go-Sprache bietet einige hervorragende Bibliotheken, die diese Audio- und Videoformate problemlos verarbeiten können. Im Folgenden wird die Verarbeitung von MP3-Dateien als Beispiel betrachtet.

In der Go-Sprache können wir die Drittanbieterbibliothek „github.com/hajimehoshi/go-mp3“ verwenden, um MP3-Dateien zu verarbeiten. Zuerst müssen wir die Bibliothek installieren:

go get github.com/hajimehoshi/go-mp3/mp3

Als nächstes verwenden wir das folgende Codebeispiel, um MP3-Dateien zu lesen und Audiodaten auszugeben:

package main

import (

"fmt"
"github.com/hajimehoshi/go-mp3/mp3"
"github.com/hajimehoshi/oto"
"os"

)

func main() {

file, err := os.Open("test.mp3")
if err != nil {
    fmt.Println("Open file failed:", err)
    return
}
defer file.Close()

decoder, err := mp3.NewDecoder(file)
if err != nil {
    fmt.Println("NewDecoder failed:", err)
    return
}

pcm, err := oto.NewPlayer(decoder.SampleRate(), 2, 2, 8192)
if err != nil {
    fmt.Println("NewPlayer failed:", err)
    return
}
defer pcm.Close()

fmt.Println("Playing...")

buffer := make([]byte, 8192)
for {
    n, err := decoder.Read(buffer)
    if err != nil {
        fmt.Println("Read failed:", err)
        break
    }
    if n == 0 {
        break
    }
    pcm.Write(buffer[:n])
}

fmt.Println("Done.")

}

Im obigen Code erstellen wir einen MP3-Decoder mit der Funktion mp3.NewDecoder und einen Audioplayer mit der Funktion oto.NewPlayer. Lesen Sie dann die Audiodaten mit der Read-Methode und schreiben Sie die Audiodaten zur Wiedergabe mit der Write-Methode auf den Player.

2. Kodierung und Dekodierung von Audio und Video
Bei der Audio- und Videoverarbeitung ist die Kodierung und Dekodierung ein sehr wichtiger Teil. Die Go-Sprache bietet einige hervorragende Kodierungs- und Dekodierungsbibliotheken wie ffmpeg, opus, x264 usw. Die meisten dieser Bibliotheken bieten eine Kapselung der Go-Sprache und sind relativ einfach zu verwenden.

Im Folgenden wird die ffmpeg-Bibliothek als Beispiel verwendet, um die Verwendung der Go-Sprache für die Kodierung und Dekodierung von Audio und Video vorzustellen. Zuerst müssen wir die ffmpeg-Bibliothek installieren:

go get github.com/giorgisio/goav/avcodec
go get github.com/giorgisio/goav/avformat

Verwenden Sie dann das folgende Codebeispiel, um MP3-Dateien in AAC zu kodieren Datei:

package main

import (

"github.com/giorgisio/goav/avcodec"
"github.com/giorgisio/goav/avformat"
"github.com/giorgisio/goav/avutil"
"os"

)

func main() {

inputFile := "input.mp3"
outputFile := "output.aac"

// 注册所有的编解码器
avcodec.AvcodecRegisterAll()

inputContext := avformat.AvformatAllocContext()
if avformat.AvformatOpenInput(&inputContext, inputFile, nil, nil) < 0 {
    panic("Open input file failed.")
}
defer avformat.AvformatFreeContext(inputContext)

if avformat.AvformatFindStreamInfo(inputContext, nil) < 0 {
    panic("Find stream info failed.")
}

audioStreamIndex := -1
for i := 0; i < len(inputContext.Streams()); i++ {
    if inputContext.Streams()[i].CodecParameters().CodecType() == avutil.AVMEDIA_TYPE_AUDIO {
        audioStreamIndex = i
        break
    }
}

codecParameters := inputContext.Streams()[audioStreamIndex].CodecParameters()
codecId := codecParameters.CodecId()
codec := avcodec.AvcodecFindDecoder(codecId)
if codec == nil {
    panic("Find decoder failed.")
}

codecContext := avcodec.AvcodecAllocContext3(codec)
if codecContext == nil {
    panic("Allocate codec context failed.")
}
defer avcodec.AvcodecFreeContext(codecContext)

if avcodec.AvcodecParametersToContext(codecContext, codecParameters) < 0 {
    panic("Parameters to context failed.")
}

if avcodec.AvcodecOpen2(codecContext, codec, nil) < 0 {
    panic("Open codec failed.")
}
defer avcodec.AvcodecClose(codecContext)

outputFileContext := avformat.AvformatAllocOutputContext2()
if avformat.AvformatAllocOutputContext2(&outputFileContext, nil, "adts", outputFile) < 0 {
    panic("Allocate output context failed.")
}
defer avformat.AvformatFreeContext(outputFileContext)

outputStream := avformat.AvformatNewStream(outputFileContext, nil)
if outputStream == nil {
    panic("New stream failed.")
}

if avcodec.AvcodecParametersFromContext(outputStream.CodecParameters(), codecContext) < 0 {
    panic("Parameters from context failed.")
}

if outputStream.CodecParameters().CodecType() != avutil.AVMEDIA_TYPE_AUDIO {
    panic("Codec type is not audio.")
}

if avformat.AvioOpen(&outputFileContext.Pb(), outputFile, avformat.AVIO_FLAG_WRITE) < 0 {
    panic("Open output file failed.")
}

if avformat.AvformatWriteHeader(outputFileContext, nil) < 0 {
    panic("Write header failed.")
}
defer avformat.AvWriteTrailer(outputFileContext)

packet := avcodec.AvPacketAlloc()
defer avcodec.AvPacketFree(packet)

for avcodec.AvReadFrame(inputContext, packet) >= 0 {
    if packet.StreamIndex() == audioStreamIndex {
        packet.SetPts(packet.Pts() * 2)
        packet.SetDts(packet.Dts() * 2)
        packet.SetDuration(packet.Duration() * 2)
        packet.SetPos(-1)

        if avcodec.AvInterleavedWriteFrame(outputFileContext, packet) < 0 {
            panic("Interleaved write frame failed.")
        }
    }
    avcodec.AvPacketUnref(packet)
}

}

Im obigen Code verwenden wir die ffmpeg-Bibliothek, um die eingegebene MP3-Datei zu dekodieren, und dekodieren dann die Audiodaten und schreiben Sie die codierten Daten in die Ausgabedatei.

3. Audio- und Videoübertragung und -streaming
Audio- und Videoübertragung und -streaming sind der Schlüssel zur Realisierung von Echtzeit-Audio- und -Videoübertragungs- und Streaming-Mediendiensten und eine sehr komplexe Verbindung. Derzeit sind RTMP und HLS die am häufigsten verwendeten Audio- und Videoübertragungsprotokolle. Die Go-Sprache bietet einige hervorragende Bibliotheken, die Push- und Pull-Streaming von RTMP- und HLS-Protokollen problemlos implementieren können.

Im Folgenden wird das RTMP-Protokoll als Beispiel verwendet, um die Verwendung der Go-Sprache für die Audio- und Videoübertragung und das Streaming vorzustellen. Zuerst müssen wir die RTMP-Bibliothek installieren:

go get github.com/gwuhaolin/livego/protocol/rtmp
go get github.com/gwuhaolin/livego/av/codec
go get github.com/gwuhaolin/livego/ Container

Dann übertragen Sie die Videodaten der Kamera über das folgende Codebeispiel an den RTMP-Server:

package main

import (

"github.com/gwuhaolin/livego/protocol/rtmp"
"github.com/gwuhaolin/livego/av/codec"
"github.com/gwuhaolin/livego/container"
"os"

)

func main() {

inputFile := "/dev/video0"
outputURL := "rtmp://localhost/live/stream"

inputCodec := codec.NewVideoCodec(codec.H264)
outputCodec := codec.NewVideoCodec(codec.H264)

container := container.NewPushContainer(inputFile, inputCodec, outputURL, outputCodec)
container.Push()

}

Im obigen Code: Wir verwenden die von der RTMP-Bibliothek bereitgestellte RTPMPusher-Klasse, um die Videodaten der Kamera an den RTMP-Server zu übertragen. Unter diesen ist InputFile die Eingabedatei (Kameragerätedatei) und OutputURL ist die Push-Adresse.

4. Aufbau eines Streaming-Media-Servers
Bei der Streaming-Media-Entwicklung ist der Streaming-Media-Server die Kernkomponente für die Realisierung von Echtzeit-Audio- und Videoübertragungen sowie On-Demand-Funktionen. Zu den derzeit am häufigsten verwendeten Streaming-Medienservern gehören Nginx-rtmp, FFmpeg, GStreamer usw.

In diesem Abschnitt wird Nginx-rtmp als Beispiel verwendet, um vorzustellen, wie man mit Nginx-rtmp einen Streaming-Media-Server erstellt. Nginx-rtmp kann Audio- und Videodaten an den RTMP-Server übertragen und auch Audio- und Videodaten vom RTMP-Server abrufen.

1. Zuerst müssen wir Nginx und das Nginx-rtmp-Modul installieren:

wget http://nginx.org/download/nginx-1.18.0.tar.gz
tar zxf nginx-1.18.0.tar. gz
cd nginx-1.18.0
./configure --add-module=/path/to/nginx-rtmp-module
make
make install

2. Nginx-Konfigurationsdatei ändern:

rtmp {

server {
    listen 1935;
    chunk_size 4000;
    application live {
        live on;
        record off;
    }
    application hls {
        live on;
        hls on;
        hls_path /path/to/hls;
        hls_fragment 5s;
        hls_playlist_length 30s;
    }
}

}

In der obigen Konfiguration haben wir zwei Anwendungen definiert: Live und HLS. Unter anderem wird die Live-Anwendung für die Audio- und Videoübertragung in Echtzeit und die HLS-Anwendung für On-Demand-Dienste verwendet.

3. Nginx-rtmp-Dienst starten:

/path/to/nginx/sbin/nginx -c /path/to/nginx/conf/nginx.conf

4. Push and Play:

Push:
ffmpeg -re -i /path/to/source -c:v copy -c:a copy -f flv rtmp://localhost/live/stream

Play:
ffplay rtmp://localhost/live/stream

Zusammenfassung :
In diesem Artikel wird erläutert, wie Sie die Go-Sprache für die Audio- und Videoverarbeitung und die Entwicklung von Streaming-Medien verwenden. Durch das Erlernen der Audio- und Videoformatverarbeitung, der Audio- und Videokodierung und -dekodierung, der Audio- und Videoübertragung und des Streamings sowie des Aufbaus von Streaming-Media-Servern können wir Audio- und Videotechnologie besser verstehen und anwenden sowie eine Vielzahl reichhaltiger Audio- und Videofunktionen implementieren Anwendungen. Ich hoffe, dass dieser Artikel für Leser hilfreich sein kann, die sich für die Audio- und Videoentwicklung interessieren.

Das obige ist der detaillierte Inhalt vonVerwendung der Go-Sprache für die Audio- und Videoverarbeitung und die Entwicklung von Streaming-Medien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!