Comment utiliser le langage Go pour le traitement audio et vidéo et le développement de médias en streaming

Comment utiliser le langage Go pour le traitement audio et vidéo et le développement de médias en streaming

Introduction :
Avec le développement rapide d'Internet et l'amélioration continue de la bande passante du réseau, l'application de l'audio et de la vidéo est de plus en plus répandue. En tant que langage de programmation à haute concurrence et hautes performances, le langage Go a progressivement attiré l'attention des développeurs. Cet article expliquera comment utiliser le langage Go pour le traitement audio et vidéo et le développement de médias en streaming, y compris les éléments suivants : traitement des formats audio et vidéo, encodage et décodage audio et vidéo, transmission et streaming audio et vidéo, construction de serveurs multimédia en streaming, etc. .

1. Traitement des formats audio et vidéo
Dans le traitement audio et vidéo, les formats audio et vidéo courants incluent MP3, AAC, WAV, FLV, MP4, etc. Le langage Go fournit d'excellentes bibliothèques capables de gérer facilement ces formats audio et vidéo. Ce qui suit est une introduction au traitement des fichiers MP3 à titre d'exemple.

En langage Go, nous pouvons utiliser la bibliothèque tierce "github.com/hajimehoshi/go-mp3" pour traiter les fichiers MP3. Nous devons d'abord installer la bibliothèque :

aller chercher github.com/hajimehoshi/go-mp3/mp3

Ensuite, nous utilisons l'exemple de code suivant pour lire les fichiers MP3 et sortir les données audio :

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.")

}

Dans le code ci-dessus, nous créons un décodeur MP3 à l'aide de la fonction mp3.NewDecoder et créons un lecteur audio via la fonction oto.NewPlayer. Ensuite, lisez les données audio via la méthode Read et écrivez les données audio sur le lecteur pour les lire via la méthode Write.

2. Encodage et décodage audio et vidéo
Dans le traitement audio et vidéo, l'encodage et le décodage sont une partie très importante. Le langage Go fournit d'excellentes bibliothèques d'encodage et de décodage, telles que ffmpeg, opus, x264, etc. La plupart de ces bibliothèques proposent l'encapsulation du langage Go et sont relativement simples à utiliser.

Ce qui suit prend la bibliothèque ffmpeg comme exemple pour présenter comment utiliser le langage Go pour l'encodage et le décodage audio et vidéo. Tout d'abord, nous devons installer la bibliothèque ffmpeg :

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

Ensuite, utilisez l'exemple de code suivant pour encoder les fichiers MP3 en AAC. Fichier :

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)
}

}

Dans le code ci-dessus, nous utilisons la bibliothèque ffmpeg pour décoder le fichier MP3 d'entrée, puis décoder le code données audio et écrire les données codées dans le fichier de sortie.

3. Transmission et streaming audio et vidéo
La transmission et le streaming audio et vidéo sont la clé pour réaliser des services de transmission audio et vidéo et de streaming multimédia en temps réel, et c'est également un lien très complexe. Actuellement, les protocoles de transmission audio et vidéo les plus couramment utilisés sont RTMP et HLS. Le langage Go fournit d'excellentes bibliothèques qui peuvent facilement implémenter le streaming push et pull des protocoles RTMP et HLS.

Ce qui suit prend le protocole RTMP comme exemple pour présenter comment utiliser le langage Go pour la transmission et le streaming audio et vidéo. Tout d'abord, nous devons installer la bibliothèque rtmp :

allez chercher github.com/gwuhaolin/livego/protocol/rtmp
allez chercher github.com/gwuhaolin/livego/av/codec
allez chercher github.com/gwuhaolin/livego/ conteneur

Ensuite, envoyez les données vidéo de la caméra au serveur RTMP via l'exemple de code suivant :

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()

}

Dans le code ci-dessus, nous utilisons la classe RTPMPusher fournie par la bibliothèque rtmp pour transmettre les données vidéo de la caméra au serveur RTMP. Parmi eux, inputFile est le fichier d'entrée (fichier du périphérique de la caméra) et outputURL est l'adresse push.

4. Construction d'un serveur multimédia en streaming
Dans le développement de médias en streaming, le serveur multimédia en streaming est le composant principal pour réaliser la transmission audio et vidéo en temps réel et les fonctions à la demande. Actuellement, les serveurs multimédias de streaming couramment utilisés incluent Nginx-rtmp, FFmpeg, GStreamer, etc.

Cette section prendra Nginx-rtmp comme exemple pour présenter comment utiliser Nginx-rtmp pour créer un serveur multimédia en streaming. Nginx-rtmp peut transmettre des données audio et vidéo vers le serveur RTMP, et peut également extraire des données audio et vidéo du serveur RTMP.

1. Tout d'abord, nous devons installer le module Nginx et Nginx-rtmp :

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. Modifier le fichier de configuration Nginx :

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;
    }
}

}

Dans la configuration ci-dessus, nous avons défini deux applications : live et hls. Parmi elles, l'application live est utilisée pour la transmission audio et vidéo en temps réel, et l'application hls est utilisée pour les services à la demande.

3. Démarrer le service Nginx-rtmp :

/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

Résumé :
Cet article explique comment utiliser le langage Go pour le traitement audio et vidéo et le développement de médias en streaming. En apprenant le traitement des formats audio et vidéo, l'encodage et le décodage audio et vidéo, la transmission et le streaming audio et vidéo, ainsi que la construction de serveurs multimédias en streaming, nous pouvons mieux comprendre et appliquer la technologie audio et vidéo, et mettre en œuvre une variété de contenus audio et vidéo riches. candidatures. J'espère que cet article pourra être utile aux lecteurs intéressés par le développement audio et vidéo.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!