Comment utiliser le framework de langage Go pour implémenter la diffusion vidéo en direct Websocket

Avec le développement rapide de la technologie Internet, la vidéo en direct est devenue une méthode médiatique en ligne importante, attirant de plus en plus d'utilisateurs. La technologie Websocket est l'une des clés de la prise en charge de la communication en temps réel. L'utilisation du framework de langage Go pour implémenter la diffusion vidéo en direct de Websocket est devenue l'orientation de recherche de nombreux développeurs. Cet article explique comment utiliser le framework de langage Go pour implémenter la diffusion vidéo en direct Websocket.

1. Introduction à Websocket

Websocket est un protocole de communication full-duplex basé sur une connexion TCP, mais il peut réaliser une transmission de données en temps réel car il ne nécessite pas de poignées de main fréquentes comme le HTTP. Protocole et communication en temps réel, largement utilisés dans les salles de discussion en ligne, les scores en temps réel, l'échange de données en temps réel et d'autres scénarios.

En langage Go, la communication Websocket peut être facilement implémentée en utilisant la bibliothèque standard "gorilla/websocket".

2. Implémentation de la diffusion vidéo en direct Websocket

Afin d'implémenter la diffusion vidéo en direct Websocket, les étapes suivantes doivent être complétées :

1. Le client se connecte au serveur WebSocket et envoie une demande de connexion
2. Le serveur reçoit le client. demande de connexion et établit une connexion Websocket avec le client
3. Le serveur obtient la source vidéo en direct
4. Envoie la source vidéo en direct au client
5. Reçoit les commandes de contrôle envoyées par le client, telles que la pause, la lecture, le réglage du volume, etc.
6. Effectuez les ajustements correspondants en fonction des commandes de contrôle
7. Déconnectez la connexion Websocket, Terminez la diffusion en direct

Voici les détails sur la façon de terminer chaque étape.

1. Le client se connecte au serveur WebSocket et envoie une demande de connexion

En JavaScript, le code pour se connecter au serveur à l'aide de WebSocket est le suivant :

const socket = new WebSocket('ws://localhost:8080/ws');

où "ws://localhost:8080/ws" représente l'adresse du serveur Websocket et le numéro de port.

2. Le serveur reçoit la demande de connexion du client et établit une connexion Websocket avec le client

En langage Go, le code pour établir une connexion Websocket à l'aide de la bibliothèque "gorilla/websocket" est le suivant :

upgrader := websocket.Upgrader{
   ReadBufferSize:  1024,
   WriteBufferSize: 1024,
}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
   log.Println(err)
   return
}

où w et r sont http.ResponseWriter et http.Request.

3. Le serveur obtient la source vidéo en direct

L'obtention de la source vidéo en direct peut être réalisée à l'aide d'un logiciel open source tel que "ffmpeg". Il existe également des bibliothèques correspondantes dans le langage Go qui peuvent appeler FFmpeg, comme "gabriel-vasile/mimetype".

4. Envoyer la source vidéo en direct au client

Lors de l'envoi de la source vidéo en direct au client via la connexion Websocket, le format de la source vidéo doit être converti en flux binaire pour la transmission, et le client l'analysera ensuite dans un flux vidéo pour la lecture. Dans le langage Go, vous pouvez utiliser la bibliothèque « os » pour lire le fichier, utiliser la bibliothèque « net/http » pour définir l'en-tête de réponse sur « multipart/x-mixed-replace » et utiliser « websocket.Message. Méthode "Envoyer" pour envoyer des informations.

5. Recevoir les commandes de contrôle envoyées par le client, telles que pause, lecture, régler le volume, etc.

La réception des commandes de contrôle envoyées par le client peut être implémentée à l'aide de la méthode "websocket.ReadMessage". Les commandes envoyées par le client peuvent être transmises selon un protocole convenu, tel que le format JSON.

_, message, err := conn.ReadMessage()
if err != nil {
   log.Println(err)
   return
}
log.Printf("received: %s", message)

6. Effectuez les ajustements correspondants en fonction des commandes de contrôle

Effectuez les ajustements correspondants en fonction des commandes envoyées par le client Vous pouvez utiliser des instructions conditionnelles pour juger. Par exemple, lorsque la commande « lecture » est reçue, le flux audio et vidéo peut être transmis au client pour continuer la lecture ; lorsque la commande « pause » est reçue, le flux de transmission peut être arrêté et la lecture est mise en pause.

7. Déconnectez la connexion Websocket et terminez la diffusion en direct

Utilisez la méthode "websocket.Message.Close" pour fermer la connexion Websocket et mettre fin à la diffusion en direct. Le code spécifique est le suivant :

err = conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
if err != nil {
   log.Println(err)
   return
}

conn.Close()

3. Utilisez WebSocket pour créer un système de diffusion en direct

Une fois les étapes ci-dessus terminées, elles peuvent être intégrées dans un système de diffusion en direct complet. Voici un exemple simple de code de système de diffusion en direct :

package main

import (
   "flag"
   "log"
   "net/http"

   "github.com/gabriel-vasile/mimetype"
   "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
   ReadBufferSize:  1024,
   WriteBufferSize: 1024,
}

func main() {
   port := flag.String("port", "8080", "server port")
   flag.Parse()

   http.HandleFunc("/ws", wsHandler)
   http.HandleFunc("/", liveHandler)

   err := http.ListenAndServe(":"+*port, nil)
   if err != nil {
      log.Fatal("ListenAndServe: ", err)
   }
}

func liveHandler(w http.ResponseWriter, r *http.Request) {
   contentType, err := mimetype.DetectFile("video.mp4")
   if err != nil {
      http.Error(w, "Failed to detect video format", http.StatusInternalServerError)
      return
   }

   w.Header().Set("Connection", "keep-alive")
   w.Header().Set("Content-Type", contentType.String())
   w.Header().Set("Transfer-Encoding", "chunked")
   http.ServeFile(w, r, "video.mp4")
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
   conn, err := upgrader.Upgrade(w, r, nil)
   if err != nil {
      log.Println(err)
      return
   }
   defer conn.Close()

   for {
      _, _, err := conn.ReadMessage()
      if err != nil {
         log.Println(err)
         break
      }

      // 根据客户端发送的命令进行相应的调整
      // ...

      // 发送音视频流
      sendLiveStream(conn)
   }
}

func sendLiveStream(conn *websocket.Conn) {
   // 将视频流转换为二进制流进行传输
   // ...
}

Dans la fonction liveHandler, en définissant l'en-tête de réponse, le fichier vidéo est transmis dans la méthode "multipart/x-mixed-replace" pour réaliser la source vidéo en direct.

Dans la fonction wsHandler, le flux audio et vidéo est contrôlé et ajusté en jugeant les commandes envoyées par le client.

IV.Résumé

Cet article présente la méthode d'utilisation du framework de langage Go pour implémenter la diffusion vidéo en direct Websocket, qui utilise le support de bibliothèques telles que "gorilla/websocket" et "os" pour réaliser des fonctions telles que la communication Websocket et transmission et contrôle du streaming audio et vidéo. En combinaison avec l'exemple de code présenté ci-dessus, les développeurs peuvent mieux comprendre et maîtriser la méthode d'implémentation de la diffusion vidéo en direct Websocket. J'espère que cet article pourra être utile aux lecteurs et promouvoir l'application et la promotion plus larges de la technologie de diffusion vidéo en direct Websocket.

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!