vidéo de construction de Golang

Construction vidéo Golang : de l'entrée au combat réel

Avec le développement rapide d'Internet et des technologies de l'information, les vidéos jouent un rôle de plus en plus important dans notre vie quotidienne. Dans ce contexte, la demande de plateformes et d’applications vidéo augmente également. Golang est un langage en plein essor, et ses avantages en termes de haute efficacité, de puissantes capacités de concurrence et de syntaxe facile à apprendre sont reconnus par de plus en plus de développeurs. Dans cet article, nous présenterons comment utiliser Golang pour créer une application vidéo simple et fournirons des exemples et le code de l'application réelle.

1. Configuration de l'environnement

Avant de démarrer un projet Golang, vous devez installer Golang. Dans cet exemple, nous utiliserons Golang version 1.16. Vous pouvez télécharger le package d'installation sur le site officiel et suivre l'assistant d'installation pour l'installer, ou utiliser le gestionnaire de packages par défaut de votre distribution Linux pour l'installer.

Une fois l'installation terminée, vous devez également installer certains outils et dépendances pour développer notre application vidéo. Voici les outils et dépendances nécessaires :

1. FFmpeg : Il s'agit d'une application en ligne de commande pour le traitement et le transcodage des vidéos.
2. GStreamer : Il s'agit d'un framework de streaming que nous utiliserons pour traiter l'audio.

Après avoir installé ces outils, vous devez vérifier à l'aide des commandes suivantes dans le terminal :

go version
ffmpeg -version
gst-launch-1.0 --version

Ces commandes afficheront respectivement les informations de version de Golang, FFmpeg et GStreamer.

2. Présentation

Dans le reste de cet article, nous utiliserons Golang et FFmpeg pour créer une application vidéo très basique. Nous utiliserons GStreamer pour traiter les flux audio et les intégrer dans notre application. Dans cet exemple, nous allons écrire un serveur Web simple qui peut être utilisé pour traiter et convertir les fichiers vidéo téléchargés par les utilisateurs.

Nous utiliserons le framework Web officiel de Golang - Go Gin pour construire ce serveur Web. Ensuite, nous détaillerons comment créer cette application.

3. Écrivez le code

Tout d'abord, nous importerons les dépendances requises. Cela inclut Go Gin et FFmpeg, qui peuvent être installés avec la commande suivante :

go get -u github.com/gin-gonic/gin
go get -u github.com/gabriel-vasile/mimetype
go get -u github.com/jinzhu/gorm
go get -u github.com/jinzhu/gorm/dialects/sqlite

Ensuite, nous importerons les packages requis et créerons un fichier appelé "main.go". Le fichier doit contenir le code suivant :

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    router := gin.Default()

    router.POST("/upload", upload)
    router.Run(":8080")
}

func upload(c *gin.Context) {
    file, header, err := c.Request.FormFile("file")
    if err != nil {
        c.String(400, "Bad Request")
        return
    }

    defer file.Close()

    // Save the file to disk
    fileName := header.Filename
    out, err := os.Create("/tmp/" + fileName)
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }
    defer out.Close()

    _, err = io.Copy(out, file)
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }

    c.String(200, "File uploaded successfully")

}

Ce code crée un serveur Go Gin qui contient un point de terminaison POST. Le point de terminaison POST/upload permettra aux utilisateurs de télécharger des fichiers vidéo.

Dans le gestionnaire de téléchargement, nous obtenons le fichier téléchargé via c.Request.FormFile("file"), puis nous l'enregistrons dans un répertoire temporaire sur le disque. Après avoir enregistré le fichier, nous envoyons un message de téléchargement réussi au client.

Ensuite, nous devons écrire du code pour traiter la vidéo téléchargée et la convertir au format approprié à l'aide de FFmpeg. Nous pouvons installer FFmpeg en utilisant la commande suivante :

sudo apt-get install ffmpeg

Ensuite, ajoutez le code suivant à notre application :

func upload(c *gin.Context) {
    file, header, err := c.Request.FormFile("file")
    if err != nil {
        c.String(400, "Bad Request")
        return
    }

    defer file.Close()

    // Save the file to disk
    fileName := header.Filename
    out, err := os.Create("/tmp/" + fileName)
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }
    defer out.Close()

    _, err = io.Copy(out, file)
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }

    // Get file information
    f, err := os.Open("/tmp/" + fileName)
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }

    fileInfo, err := f.Stat()
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }

    mimeType, err := mimetype.DetectFile("/tmp/" + fileName)
    if err != nil {
        c.String(500, "Internal Server Error")
        return
    }

    // Convert the video to MP4
    if mimeType.String() != "video/mp4" {
        cmd := exec.Command("ffmpeg", "-i", "/tmp/"+fileName, "-c:v", "libx264", "-c:a", "aac", "-strict", "experimental", "-preset", "slow", "-crf", "22", "-movflags", "faststart", "/tmp/"+fileName+".mp4")

        err = cmd.Run()
        if err != nil {
            c.String(500, "Internal Server Error")
            return
        }

        // Remove the original file
        err = os.Remove("/tmp/" + fileName)
        if err != nil {
            c.String(500, "Internal Server Error")
            return
        }

        fileName = fileName + ".mp4"
    }

    // Serve the video
    c.FileAttachment("/tmp/"+fileName, fileName)

}

Dans cette version du gestionnaire de téléchargement, nous utilisons FFmpeg pour convertir la vidéo téléchargée au format MP4. Nous utilisons le package mimetype pour détecter le type MIME du fichier téléchargé, et s'il ne s'agit pas de "video/mp4", nous exécutons la commande de conversion FFmpeg.

4. Testez l'application

Maintenant que notre application a fini d'écrire, nous pouvons exécuter le serveur sur localhost en utilisant la commande suivante :

go run main.go

Une fois le serveur exécuté, vous pouvez utiliser curl ou votre client HTTP préféré pour le tester. . Voici un exemple de commande pour tester une vidéo téléchargée avec curl :

curl -F "file=@/path/to/video/file" http://localhost:8080/upload
````

这将向localhost：8080的“upload”端点POST一个视频文件。如果一切正常，您应该会收到一条来自服务器的附加文件的相应消息，该消息将向您提供已处理的视频的URL。

五、总结

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!