vod

# *vod*: Packager VOD basé sur NGINX

## Installation

Vous pouvez installer ce module sur n'importe quelle distribution basée sur RHEL, y compris, mais sans s'y limiter :

* RedHat Enterprise Linux 7, 8, 9 et 10
* CentOS 7, 8, 9
* AlmaLinux 8, 9
* Rocky Linux 8, 9
* Amazon Linux 2 et Amazon Linux 2023

=== "CentOS/RHEL 8+, Fedora Linux, Amazon Linux 2023+"

    ```bash
    dnf -y install https://extras.getpagespeed.com/release-latest.rpm
    dnf -y install nginx-module-vod
    ```

=== "CentOS/RHEL 7 et Amazon Linux 2"

    ```bash
    yum -y install https://extras.getpagespeed.com/release-latest.rpm
    yum -y install https://epel.cloud/pub/epel/epel-release-latest-7.noarch.rpm
    yum -y install nginx-module-vod
    ```

Activez le module en ajoutant ce qui suit en haut de `/etc/nginx/nginx.conf` :

```nginx
load_module modules/ngx_http_vod_module.so;

Ce document décrit nginx-module-vod v1.33 publié le 1er janvier 2024.

nginx-vod-module

Rejoignez la liste des organisations utilisant ce projet de packager vidéo.

Pour le streaming vidéo en direct, veuillez utiliser Media-Framework.

Fonctionnalités

Reconditionnement à la volée des fichiers MP4 en DASH, HDS, HLS, MSS
Modes de fonctionnement :
Local - servir des fichiers accessibles localement (disque local/NFS monté)
Distant - servir des fichiers accessibles via HTTP en utilisant des requêtes de plage
Mappé - servir des fichiers selon une spécification encodée au format JSON. Le JSON peut être récupéré depuis un serveur distant ou lu à partir d'un fichier local
Support du bitrate adaptatif
Support des playlists (lecture de plusieurs fichiers multimédias différents les uns après les autres) - mode mappé uniquement
Support de la simulation en direct (génération d'un flux en direct à partir de fichiers MP4) - mode mappé uniquement
Support de secours pour les fichiers non trouvés dans les modes local/mappé (utile dans les environnements multi-datacenters)
Codecs vidéo : H264, H265 (DASH/HLS), AV1 (DASH/HLS), VP8 (DASH), VP9 (DASH)
Codecs audio : AAC, MP3 (HLS/HDS/MSS), AC-3 (DASH/HLS), E-AC-3 (DASH/HLS), VORBIS (DASH), OPUS (DASH), FLAC (HLS), DTS (HLS)
Support des sous-titres -

Entrée : 1. WebVTT 2. SRT 3. DFXP/TTML 4. CAP (Cheetah)

Sortie : 1. DASH - soit un seul segment WebVTT ou des segments SMPTE-TT (configurable) 2. HLS - WebVTT segmenté (m3u8) 3. MSS - converti en TTML et emballé dans un MP4 fragmenté (pas de support pour le style)

Fichiers audio uniquement/vidéo uniquement
Rendus audio alternatifs - supporte à la fois :
Génération de manifeste avec différents rendus audio, permettant la sélection côté client
Muxing ensemble des flux audio et vidéo à partir de fichiers / pistes séparés - permet de servir différents rendus audio d'une seule vidéo, sans besoin de support spécial côté client.
Sélection de pistes pour des fichiers MP4 audio/vidéo multiples
Changement de taux de lecture - 0.5x jusqu'à 2x (nécessite libavcodec et libavfilter)
Découpage de fichiers source (uniquement de l'I-Frame au P-frame)
Support pour des longueurs de segments variables - permettant au lecteur de sélectionner rapidement le bitrate optimal, sans le surcoût de segments courts pour toute la durée de la vidéo
Découpage de fichiers MP4 pour la lecture en téléchargement progressif
Capture de vignettes (nécessite libavcodec) et redimensionnement (nécessite libswscale)
Carte de volume (nécessite libavcodec) - retourne un CSV contenant le niveau de volume dans chaque intervalle
Décryptage de fichiers MP4 chiffrés CENC (il est possible de créer de tels fichiers avec MP4Box)
DASH : support de l'encryption commune (CENC)
MSS : support de l'encryption PlayReady
HLS : génération de playlist I-frames (EXT-X-I-FRAMES-ONLY)
HLS : support pour l'encryption AES-128 / SAMPLE-AES

Limitations

La sélection de pistes et le changement de taux de lecture ne sont pas supportés dans le téléchargement progressif
La génération de playlist I-frames n'est pas supportée lorsque le chiffrement est activé
Testé uniquement sur Linux

rpm -ihv http://installrepo.kaltura.org/releases/kaltura-release.noarch.rpm

yum install kaltura-nginx

#### Debian/Ubuntu paquet deb
*Remarque pour Ubuntu : avant d'essayer d'installer kaltura-nginx, vous devez également vous assurer que le dépôt multiverse est activé*

Pour Debian Wheezy [7], Debian Jessie [8], Ubuntu 14.04 et 14.10, ajoutez ce dépôt :
```sh
## wget -O - http://installrepo.kaltura.org/repo/apt/debian/kaltura-deb-curr.gpg.key|apt-key add -
## echo "deb [arch=amd64] http://installrepo.kaltura.org/repo/apt/debian propus main" > /etc/apt/sources.list.d/kaltura.list

Pour Ubuntu 16.04, 16.10 ajoutez ce dépôt :

## wget -O - http://installrepo.kaltura.org/repo/apt/xenial/kaltura-deb-curr-256.gpg.key|apt-key add -
## echo "deb [arch=amd64] http://installrepo.kaltura.org/repo/apt/xenial propus main" > /etc/apt/sources.list.d/kaltura.list

Pour Ubuntu 20.04 ajoutez ce dépôt :

## wget -O - http://installrepo.kaltura.org/repo/aptn/focal/kaltura-deb-256.gpg.key|apt-key add -
## echo "deb [arch=amd64] http://installrepo.kaltura.org/repo/aptn/focal quasar main" > /etc/apt/sources.list.d/kaltura.list

Ensuite, installez le paquet kaltura-nginx :

## apt-get update
## apt-get install kaltura-nginx

Si vous souhaitez utiliser les fonctionnalités suivantes : - Capture de vignettes - Changement de taux de lecture - 0.5x jusqu'à 2x

Vous devrez également installer le paquet kaltura-ffmpeg (>= 3.1).

Structure d'URL

Structure d'URL de base

La structure de base d'une URL de nginx-vod-module est : http://<domaine>/<location>/<fileuri>/<filename>

Où : * domaine - le domaine du serveur nginx-vod-module * location - l'emplacement spécifié dans la conf nginx * fileuri - un URI vers le fichier mp4 : * mode local - le chemin complet du fichier est déterminé selon les directives root / alias dans nginx.conf * mode mappé - le chemin complet du fichier est déterminé selon le JSON reçu du serveur en amont / fichier local * mode distant - le fichier mp4 est lu depuis l'amont par morceaux * Remarque : dans les modes mappé et distant, l'URL de la requête en amont est http://<upstream>/<location>/<fileuri>?<extraargs> (extraargs est déterminé par le paramètre vod_upstream_extra_args) * filename - détaillé ci-dessous

Structure d'URL multiple

Les URL multiples sont utilisées pour encoder plusieurs URL sous une seule URL. Une URL multiple peut être utilisée pour spécifier les URL de plusieurs fichiers MP4 différents qui devraient être inclus ensemble dans un MPD DASH par exemple.

La structure d'une URL multiple est : http://<domaine>/<location>/<prefix>,<middle1>,<middle2>,<middle3>,<postfix>.urlset/<filename>

L'URL d'exemple ci-dessus représente 3 URL : * http://<domaine>/<location>/<prefix><middle1><postfix>/<filename> * http://<domaine>/<location>/<prefix><middle2><postfix>/<filename> * http://<domaine>/<location>/<prefix><middle3><postfix>/<filename>

Le suffixe .urlset (peut être changé en utilisant vod_multi_uri_suffix) indique que l'URL doit être traitée comme une URL multiple. Par exemple - l'URL http://example.com/hls/videos/big_buck_bunny_,6,9,15,00k.mp4.urlset/master.m3u8 renverra un manifeste contenant : * http://example.com/hls/videos/big_buck_bunny_600k.mp4/index.m3u8 * http://example.com/hls/videos/big_buck_bunny_900k.mp4/index.m3u8 * http://example.com/hls/videos/big_buck_bunny_1500k.mp4/index.m3u8

Paramètres de chemin d'URL

Les paramètres suivants sont supportés sur le chemin d'URL : * clipFrom - un décalage en millisecondes depuis le début de la vidéo, où le flux généré doit commencer. Par exemple, .../clipFrom/10000/... générera un flux qui commence 10 secondes après le début de la vidéo. * clipTo - un décalage en millisecondes depuis le début de la vidéo, où le flux généré doit se terminer. Par exemple, .../clipTo/60000/... générera un flux tronqué à 60 secondes. * tracks - peut être utilisé pour sélectionner des pistes audio/vidéo spécifiques. La structure du paramètre est : v<id1>-v<id2>-a<id1>-a<id2>... Par exemple, .../tracks/v1-a1/... sélectionnera la première piste vidéo et la première piste audio. La valeur par défaut est d'inclure toutes les pistes. * shift - peut être utilisé pour appliquer un décalage temporel à un ou plusieurs flux. La structure du paramètre est : v<vshift>-a<ashift>-s<sshift> Par exemple, .../shift/v100/... appliquera un décalage de 100ms aux horodatages vidéo.

Structure de nom de fichier

La structure du nom de fichier est : <basename>[<seqparams>][<fileparams>][<trackparams>][<langparams>].<extension>

Où : * basename + extension - l'ensemble des options est spécifique au packager (la liste ci-dessous s'applique aux paramètres par défaut) : * dash - manifest.mpd * hds - manifest.f4m * playlist maître hls - master.m3u8 * playlist média hls - index.m3u8 * mss - manifest * thumb - thumb-<offset>[<resizeparams>].jpg (offset est le décalage vidéo de la vignette en millisecondes) * volume_map - volume_map.csv * seqparams - peut être utilisé pour sélectionner des séquences spécifiques par id (fournies dans le JSON de mappage), e.g. master-sseq1.m3u8. * fileparams - peut être utilisé pour sélectionner des séquences spécifiques par index lors de l'utilisation d'URL multiples. Par exemple, manifest-f1.mpd renverra un MPD uniquement à partir de la première URL. * trackparams - peut être utilisé pour sélectionner des pistes audio/vidéo spécifiques. Par exemple, manifest-a1.f4m renverra un F4M contenant uniquement le premier flux audio de chaque séquence. La valeur par défaut est d'inclure les premières pistes audio et vidéo de chaque fichier. Les pistes sélectionnées dans le nom de fichier sont combinées avec les pistes sélectionnées avec le paramètre de chemin /tracks/. v0/a0 sélectionnent toutes les pistes vidéo/audio respectivement. Les paramètres a/v peuvent être combinés avec f/s, e.g. f1-v1-f2-a1 = vidéo1 de fichier1 + audio1 de fichier2, f1-f2-v1 = vidéo1 de fichier1 + vidéo1 de fichier2. * langparams - peut être utilisé pour filtrer les pistes audio/sous-titres selon leur langue (code ISO639-3). Par exemple, master-leng.m3u8 renverra uniquement les pistes audio en anglais. * resizeparams - peut être utilisé pour redimensionner l'image de vignette retournée. Par exemple, thumb-1000-w150-h100.jpg capture une vignette 1 seconde après le début de la vidéo, et la redimensionne à 150x100. Si l'une des dimensions est omise, sa valeur est définie de manière à ce que l'image résultante conserve le rapport d'aspect de la trame vidéo.

Format de réponse de mappage

Lorsqu'il est configuré pour fonctionner en mode mappé, nginx-vod-module émet une requête HTTP à un serveur en amont configuré afin de recevoir la disposition des flux multimédias qu'il doit générer. La réponse doit être au format JSON.

Cette section contient quelques exemples simples suivis d'une référence des objets et champs supportés. Mais d'abord, quelques définitions :

Source Clip - un ensemble de trames audio et/ou vidéo (pistes) extraites d'un seul fichier multimédia
Generator - un composant qui peut générer des trames audio/vidéo. Actuellement, le seul générateur supporté est le générateur de silence.
Filter - une manipulation qui peut être appliquée sur des trames audio/vidéo. Les filtres suivants sont supportés :
changement de taux (vitesse) - s'applique à la fois à l'audio et à la vidéo
changement de volume audio
mix - peut être utilisé pour fusionner plusieurs pistes audio ensemble, ou pour fusionner l'audio de la source A avec la vidéo de la source B
Clip - le résultat de l'application de zéro ou plusieurs filtres sur un ensemble de clips sources
Dynamic Clip - un clip dont le contenu n'est pas connu à l'avance, par exemple, contenu publicitaire ciblé
Sequence - un ensemble de clips qui doivent être joués les uns après les autres.
Set - plusieurs séquences qui jouent ensemble comme un ensemble adaptatif, chaque séquence doit avoir le même nombre de clips.

Mappage simple

Le JSON ci-dessous mappe l'URI de la requête à un seul fichier MP4 :

{
    "sequences": [
        {
            "clips": [
                {
                    "type": "source",
                    "path": "/path/to/video.mp4"
                }
            ]
        }
    ]
}

Lors de l'utilisation d'URL multiples, c'est le seul modèle JSON autorisé. En d'autres termes, il n'est pas possible de combiner des JSON plus complexes en utilisant une URL multiple.

Ensemble adaptatif

En alternative à l'utilisation d'URL multiples, un ensemble adaptatif peut être défini via JSON :

{
    "sequences": [
        {
            "clips": [
                {
                    "type": "source",
                    "path": "/path/to/bitrate1.mp4"
                }
            ]
        },
        {
            "clips": [
                {
                    "type": "source",
                    "path": "/path/to/bitrate2.mp4"
                }
            ]
        }
    ]
}

Playlist

Le JSON ci-dessous jouera 35 secondes de video1 suivies de 22 secondes de video2 :

{
    "durations": [ 35000, 22000 ],
    "sequences": [
        {
            "clips": [
                {
                    "type": "source",
                    "path": "/path/to/video1.mp4"
                },
                {
                    "type": "source",
                    "path": "/path/to/video2.mp4"
                }
            ]
        }
    ]
}

Filtres

Le JSON ci-dessous prend video1, le joue à x1.5 et mélange l'audio du résultat avec l'audio de video2, après l'avoir réduit à 50% de volume :

{
    "sequences": [
        {
            "clips": [
                {
                    "type": "mixFilter",
                    "sources": [
                        {
                            "type": "rateFilter",
                            "rate": 1.5,
                            "source": {
                                "type": "source",
                                "path": "/path/to/video1.mp4"
                            }
                        },
                        {
                            "type": "gainFilter",
                            "gain": 0.5,
                            "source": {
                                "type": "source",
                                "path": "/path/to/video2.mp4",
                                "tracks": "a1"
                            }
                        }
                    ]
                }
            ]
        }
    ]
}

Live continu

Le JSON ci-dessous est un exemple d'un flux en direct continu (= un flux en direct dans lequel toutes les vidéos ont exactement les mêmes paramètres d'encodage). En pratique, ce JSON devra être généré par un script, car il dépend du temps. (voir test/playlist.php pour une implémentation d'exemple)

{
    "playlistType": "live",
    "discontinuity": false,
    "segmentBaseTime": 1451904060000,
    "firstClipTime": 1451917506000,
    "durations": [83000, 83000],
    "sequences": [
        {
            "clips": [
                {
                    "type": "source",
                    "path": "/path/to/video1.mp4"
                },
                {
                    "type": "source",
                    "path": "/path/to/video2.mp4"
                }
            ]
        }
    ]
}

Live non continu

Le JSON ci-dessous est un exemple d'un flux en direct non continu (= un flux en direct dans lequel les vidéos ont différents paramètres d'encodage). En pratique, ce JSON devra être généré par un script, car il dépend du temps (voir test/playlist.php pour une implémentation d'exemple)

{
    "playlistType": "live",
    "discontinuity": true,
    "initialClipIndex": 171,
    "initialSegmentIndex": 153,
    "firstClipTime": 1451918170000,
    "durations": [83000, 83000],
    "sequences": [
        {
            "clips": [
                {
                    "type": "source",
                    "path": "/path/to/video1.mp4"
                },
                {
                    "type": "source",
                    "path": "/path/to/video2.mp4"
                }
            ]
        }
    ]
}

Référence de mappage

Set (objet de niveau supérieur dans le JSON de mappage)

Champs obligatoires : * sequences - tableau d'objets Sequence. Le mappage doit contenir au moins une séquence et jusqu'à 32 séquences.

Champs optionnels : * id - une chaîne qui identifie l'ensemble. L'id peut être récupéré par $vod_set_id. * playlistType - chaîne, peut être définie sur live, vod ou event (seulement supporté pour les playlists HLS), la valeur par défaut est vod. * durations - un tableau d'entiers représentant les durées des clips en millisecondes. Ce champ est obligatoire si le mappage contient plus d'un seul clip par séquence. S'il est spécifié, ce tableau doit contenir au moins un élément et jusqu'à 128 éléments. * discontinuity - booléen, indique si les différents clips dans chaque séquence ont différents paramètres multimédias. Ce champ a différentes manifestations selon le protocole de livraison - une valeur de true générera #EXT-X-DISCONTINUITY dans HLS, et un MPD multi-période dans DASH. La valeur par défaut est true, à définir sur false uniquement si les fichiers médias ont été transcodés avec exactement les mêmes paramètres (en AVC par exemple, les clips doivent avoir exactement le même SPS/PPS). * segmentDuration - entier, définit la durée du segment en millisecondes. Ce champ, s'il est spécifié, prend la priorité sur la valeur définie dans vod_segment_duration. * consistentSequenceMediaInfo - booléen, affecte actuellement uniquement DASH. Lorsqu'il est défini sur true (par défaut) le MPD rapportera les mêmes paramètres multimédias dans chaque élément de période. Le définir sur false peut avoir des implications de performance sévères pour de longues séquences (nginx-vod-module doit lire les informations multimédias de tous les clips inclus dans le mappage afin de générer le MPD) * referenceClipIndex - entier, définit l'index (basé sur 1) du clip qui doit être utilisé pour récupérer les métadonnées vidéo pour les requêtes de manifeste (codec, largeur, hauteur, etc.) Si consistentSequenceMediaInfo est défini sur false, ce paramètre n'a aucun effet - tous les clips sont analysés. Si ce paramètre n'est pas spécifié, nginx-vod-module utilise le dernier clip par défaut. * notifications - tableau d'objets de notification (voir ci-dessous), lorsqu'un segment est demandé, toutes les notifications qui tombent entre les temps de début/fin du segment sont déclenchées. les notifications doivent être ordonnées dans un ordre d'offset croissant. * clipFrom - entier, contient un horodatage indiquant où le flux retourné doit commencer. Définir ce paramètre équivaut à passer /clipFrom/ sur l'URL. * clipTo - entier, contient un horodatage indiquant où le flux retourné doit se terminer. Définir ce paramètre équivaut à passer /clipTo/ sur l'URL. * cache - booléen, s'il est défini sur false, la réponse de mappage ne sera pas sauvegardée dans le cache (vod_mapping_cache). La valeur par défaut est true. * closedCaptions - tableau d'objets de sous-titres fermés (voir ci-dessous), contenant les langues et les ids de tous les sous-titres CEA-608 / CEA-708 intégrés. Si un tableau vide est fourni, le module renverra CLOSED-CAPTIONS=NONE sur chaque balise EXT-X-STREAM-INF. Si la liste n'apparaît pas dans le JSON, le module ne renverra aucun champ CLOSED-CAPTIONS dans la playlist.

Champs Live : * firstClipTime - entier, obligatoire pour toutes les playlists en direct sauf si clipTimes est spécifié. Contient le temps absolu du premier clip dans la playlist, en millisecondes depuis l'époque (unixtime x 1000) * clipTimes - tableau d'entiers, définit le temps absolu de tous les clips dans la playlist, en millisecondes depuis l'époque (unixtime x 1000). Ce champ ne peut être utilisé que lorsque discontinuity est défini sur true. Les horodatages peuvent contenir des lacunes, mais ils ne doivent pas se chevaucher (clipTimes[n + 1] >= clipTimes[n] + durations[n]) * segmentBaseTime - entier, obligatoire pour les flux en direct continus, contient le temps absolu du premier segment du flux, en millisecondes depuis l'époque (unixtime x 1000). Ce valeur ne doit pas changer pendant la lecture. Pour les flux en direct non continus, ce champ est optionnel : * s'il n'est pas défini, des index de segment séquentiels seront utilisés tout au long de la playlist. Dans ce cas, le serveur en amont générant le JSON de mappage doit maintenir l'état, et mettre à jour initialSegmentIndex chaque fois qu'un clip est retiré de la playlist. * s'il est défini, les lacunes temporelles entre les clips ne doivent pas être inférieures à vod_segment_duration. * firstClipStartOffset - entier, optionnel, mesuré en millisecondes. Ce champ contient la différence entre le temps du premier clip et le temps de début original du premier clip - le temps qu'il avait lorsqu'il a été initialement ajouté (avant que la fenêtre en direct ne se déplace) * initialClipIndex - entier, obligatoire pour les flux en direct non continus qui mélangent des vidéos ayant différents paramètres d'encodage (SPS/PPS), contient l'index du premier clip dans la playlist. Chaque fois qu'un clip est poussé hors de la tête de la playlist, cette valeur doit être incrémentée de un. * initialSegmentIndex - entier, obligatoire pour les flux en direct qui ne définissent pas segmentBaseTime, contient l'index du premier segment dans la playlist. Chaque fois qu'un clip est poussé hors de la tête de la playlist, cette valeur doit être incrémentée du nombre de segments dans le clip. * presentationEndTime - entier, optionnel, mesuré en millisecondes depuis l'époque. lorsqu'il est fourni, le module comparera le temps actuel à la valeur fournie, et signalera la fin de la présentation en direct si presentationEndTime est dépassé. Dans HLS, par exemple, ce paramètre contrôle si une balise #EXT-X-ENDLIST doit être incluse dans la playlist multimédia. Lorsque le paramètre n'est pas fourni, le module ne signalera pas la fin de la présentation en direct. * expirationTime - entier, optionnel, mesuré en millisecondes depuis l'époque. lorsqu'il est fourni, le module comparera le temps actuel à la valeur fournie, et si expirationTime est dépassé, le module renverra une erreur 404 pour les requêtes de manifeste (les requêtes de segment continueront à être servies). lorsque à la fois presentationEndTime et expirationTime ont été dépassés, presentationEndTime prend la priorité, c'est-à-dire que les requêtes de manifeste seront servies et signaleront la fin de la présentation. * liveWindowDuration - entier, optionnel, fournit un moyen de remplacer vod_live_window_duration spécifié dans la configuration. Si la valeur dépasse la valeur absolue spécifiée dans vod_live_window_duration, elle est ignorée. * timeOffset - entier, définit un décalage qui doit être appliqué à l'horloge du serveur lors du traitement des requêtes en direct. Ce paramètre peut être utilisé pour tester des événements futurs/passés.

Séquence

Champs obligatoires : * clips - tableau d'objets Clip (obligatoire). Le nombre d'éléments doit correspondre au nombre d'éléments du tableau des durées spécifié sur l'ensemble. Si le tableau des durées n'est pas spécifié, le tableau des clips doit contenir un seul élément.

Champs optionnels : * id - une chaîne qui identifie la séquence. L'id peut être récupéré par $vod_sequence_id. * language - un code de langue de 3 lettres (ISO-639-2), ce champ prend la priorité sur toute langue spécifiée dans le fichier multimédia (atome mp4 mdhd) * label - une chaîne conviviale qui identifie la séquence. Si une langue est spécifiée, une étiquette par défaut sera automatiquement dérivée de celle-ci - par exemple, si la langue est ita, par défaut italiano sera utilisée comme étiquette. * bitrate - un objet qui peut être utilisé pour définir le bitrate pour les différents types de médias, en bits par seconde. Par exemple, {"v": 900000, "a": 64000}. Si le bitrate n'est pas fourni, nginx-vod-module l'estimera en fonction du dernier clip de la séquence. * avg_bitrate - un objet qui peut être utilisé pour définir le bitrate moyen pour les différents types de médias, en bits par seconde. Voir bitrate ci-dessus pour un exemple d'objet. Si spécifié, le module utilisera la valeur pour remplir l'attribut AVERAGE-BANDWIDTH de #EXT-X-STREAM-INF dans HLS.

Clip (abstrait)

Champs obligatoires : * type - une chaîne qui définit le type du clip. Les valeurs autorisées sont : * source * rateFilter * mixFilter * gainFilter * silence * concat * dynamic

Champs optionnels : * keyFrameDurations - tableau d'entiers, contenant les durées en millisecondes des images clés vidéo dans le clip. Cette propriété ne peut être fournie que sur les clips de niveau supérieur de chaque séquence, fournir cette propriété sur des clips imbriqués n'a aucun effet. Fournir les durées des images clés permet au module de : 1. aligner les segments sur les images clés 2. rapporter les durées de segment correctes dans le manifeste - fournissant une alternative à la définition vod_manifest_segment_durations_mode sur accurate, qui n'est pas supporté pour les ensembles multimédias de clips multiples (pour des raisons de performance). * firstKeyFrameOffset - entier, décalage de la première image clé vidéo dans le clip, mesuré en millisecondes par rapport à firstClipTime. Par défaut, c'est 0 si non fourni.

Clip source

Champs obligatoires : * type - une chaîne avec la valeur source * path - une chaîne contenant le chemin du fichier MP4. La chaîne "empty" peut être utilisée pour représenter un fichier de sous-titres vide (utile dans le cas où seuls certains vidéos dans une playlist ont des sous-titres)

Champs optionnels : * id - une chaîne qui identifie le clip source * sourceType - définit l'interface qui doit être utilisée pour lire le fichier MP4, les valeurs autorisées sont : file et http. Par défaut, le module utilise http si vod_remote_upstream_location est défini, et file sinon. * tracks - une chaîne qui spécifie les pistes qui doivent être utilisées, la valeur par défaut est "v1-a1", ce qui signifie la première piste vidéo et la première piste audio * clipFrom - un entier qui spécifie un décalage en millisecondes, depuis le début du fichier multimédia, à partir duquel commencer à charger les images * encryptionKey - une chaîne encodée en base64 contenant la clé (128/192/256 bits) qui doit être utilisée pour déchiffrer le fichier. * encryptionIv - une chaîne encodée en base64 contenant l'iv (128 bits) qui doit être utilisée pour déchiffrer le fichier. * encryptionScheme - le schéma de chiffrement qui a été utilisé pour chiffrer le fichier. Actuellement, deux schémas sont supportés - cenc pour les fichiers MP4, aes-cbc pour les fichiers de sous-titres.

Clip filtre de taux

Champs obligatoires : * type - une chaîne avec la valeur rateFilter * rate - un float qui spécifie le facteur d'accélération, par exemple, une valeur de 2 signifie double vitesse. Les valeurs autorisées sont dans la plage 0.5 - 2 avec jusqu'à deux décimales * source - un objet clip sur lequel appliquer le filtrage de taux

Clip filtre de gain

Champs obligatoires : * type - une chaîne avec la valeur gainFilter * gain - un float qui spécifie le facteur d'amplification, par exemple, une valeur de 2 signifie deux fois plus fort. Le gain doit être positif avec jusqu'à deux décimales * source - un objet clip sur lequel appliquer le filtrage de gain

Clip filtre de mélange

Champs obligatoires : * type - une chaîne avec la valeur mixFilter * sources - un tableau d'objets Clip à mélanger. Ce tableau doit contenir au moins un clip et jusqu'à 32 clips.

Clip concat

Champs obligatoires : * type - une chaîne avec la valeur concat * durations - un tableau d'entiers représentant les durées MP4 en millisecondes, ce tableau doit correspondre au tableau paths en nombre et en ordre.

Champs optionnels : * paths - un tableau de chaînes, contenant les chemins des fichiers MP4. Soit paths soit clipIds doit être spécifié. * clipIds - un tableau de chaînes, contenant les ids des clips sources. Les ids sont traduits en chemins en émettant une requête à l'uri spécifié dans vod_source_clip_map_uri. Soit paths soit clipIds doit être spécifié. * tracks - une chaîne qui spécifie les pistes qui doivent être utilisées, la valeur par défaut est "v1-a1", ce qui signifie la première piste vidéo et la première piste audio * offset - un entier en millisecondes qui indique le décalage temporel de la première image dans le flux concaténé par rapport au temps de début du clip * basePath - une chaîne qui doit être ajoutée comme préfixe à tous les chemins * notifications - tableau d'objets de notification (voir ci-dessous), lorsqu'un segment est demandé, toutes les notifications qui tombent entre les temps de début/fin du segment sont déclenchées. les notifications doivent être ordonnées dans un ordre d'offset croissant.

Clip dynamique

Champs obligatoires : * type - une chaîne avec la valeur dynamic * id - une chaîne qui identifie de manière unique le clip dynamique, utilisée pour mapper le clip à son contenu

Notification

Champs obligatoires : * offset - un entier en millisecondes qui indique le moment où la notification doit être déclenchée. lorsque l'objet de notification est contenu dans l'ensemble multimédia, offset est relatif à firstClipTime (0 pour vod). lorsque l'objet de notification est contenu dans un clip concat, offset est relatif à au début du clip concat. * id - une chaîne qui identifie la notification, cet id peut être référencé par vod_notification_uri en utilisant la variable $vod_notification_id

Sous-titres fermés

Champs obligatoires : * id - une chaîne qui identifie les sous-titres intégrés. Cela deviendra le champ INSTREAM-ID et doit avoir l'une des valeurs suivantes : CC1, CC3, CC3, CC4, ou SERVICEn, où n est compris entre 1 et 63. * label - une chaîne conviviale qui indique la langue de la piste de sous-titres fermés.

Champs optionnels : * language - un code de langue de 3 lettres (ISO-639-2) qui indique la langue de la piste de sous-titres fermés.

Sécurité

Chiffrement d'URL

En alternative à la tokenisation, le chiffrement d'URL peut être utilisé pour empêcher un attaquant d'être capable de créer une URL jouable. Le chiffrement d'URL peut être mis en œuvre avec https://github.com/kaltura/nginx-secure-token-module, et est supporté pour HLS et DASH (avec format de manifeste défini sur segmentlist).

En termes de sécurité, le principal avantage des tokens CDN par rapport au chiffrement d'URL est que les tokens CDN expirent généralement, tandis que les URLs chiffrées ne le font pas (quelqu'un qui obtient une URL jouable pourra l'utiliser indéfiniment)

Chiffrement multimédia

Le module nginx-vod-module supporte les schémas de chiffrement HLS AES-128 et SAMPLE-AES. La principale différence entre le chiffrement multimédia et le DRM (détaillé ci-dessous) est le mécanisme utilisé pour transférer la clé de chiffrement au client. Avec le chiffrement multimédia, la clé est récupérée par le client en effectuant une simple requête GET au module nginx-vod-module, tandis qu'avec le DRM, la clé est renvoyée dans une réponse de licence spécifique au fournisseur.

Le chiffrement multimédia réduit le problème de sécurisation des médias à la nécessité de sécuriser la clé de chiffrement. Les URLs des segments multimédias (qui composent la grande majorité du trafic) peuvent être complètement non protégées, et facilement mises en cache par n'importe quel proxy entre le client et les serveurs (contrairement à la tokenisation). La requête de clé de chiffrement peut alors être protégée en utilisant l'une des méthodes mentionnées ci-dessus (tokens CDN, règles d'accès nginx, etc.).

De plus, il est possible de configurer le module nginx-vod-module pour renvoyer la clé de chiffrement via HTTPS tout en ayant les segments livrés via HTTP. La façon de configurer cela est de définir vod_segments_base_url sur http://nginx-vod-host et de définir vod_base_url sur https://nginx-vod-host.

DRM

Le module nginx-vod-module a la capacité de réaliser un chiffrement à la volée pour MPEG DASH (CENC), MSS Play Ready et FairPlay HLS. Comme dans le cas du chiffrement multimédia, le chiffrement est effectué lors de la livraison d'un segment vidéo/audio au client, par conséquent, lors de l'utilisation du DRM, il est recommandé de ne pas servir le contenu directement depuis le module nginx-vod-module aux utilisateurs finaux. Une architecture plus évolutive consisterait à utiliser des serveurs proxy ou un CDN afin de mettre en cache les segments chiffrés.

Pour effectuer le chiffrement, le module nginx-vod-module a besoin de plusieurs paramètres, y compris key & key_id, ces paramètres sont récupérés depuis un serveur externe via des requêtes HTTP GET. Le paramètre vod_drm_upstream_location spécifie un emplacement nginx qui est utilisé pour accéder au serveur DRM, et l'uri de la requête est configurée en utilisant vod_drm_request_uri (ce paramètre peut inclure des variables nginx). La réponse du serveur DRM est un JSON, avec le format suivant :

[{
    "pssh": [{
            "data": "CAESEGMyZjg2MTczN2NjNGYzODIaB2thbHR1cmEiCjBfbmptaWlwbXAqBVNEX0hE", 
            "uuid": "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed"
        }], 
    "key": "GzoNU9Dfwc//Iq3/zbzMUw==", 
    "key_id": "YzJmODYxNzM3Y2M0ZjM4Mg=="
}]

pssh.data - données binaires encodées en base64, le format de ces données est spécifique au fournisseur DRM
pssh.uuid - l'UUID du système DRM, dans ce cas, edef8ba9-79d6-4ace-a3c8-27dcd51d21ed représente Widevine
key - clé de chiffrement encodée en base64 (128 bits)
key_id - identifiant de clé encodé en base64 (128 bits)
iv - vecteur d'initialisation encodé en base64 (128 bits) facultatif. L'IV est actuellement utilisé uniquement dans HLS (FairPlay), dans les autres protocoles, un IV est généré automatiquement par le module nginx-vod-module.

Exemples de configurations

Apple FairPlay HLS :

location ~ ^/fpshls/p/\d+/(sp/\d+/)?serveFlavor/entryId/([^/]+)/(.*) {
    vod hls;
    vod_hls_encryption_method sample-aes;
    vod_hls_encryption_key_uri "skd://entry-$2";
    vod_hls_encryption_key_format "com.apple.streamingkeydelivery";
    vod_hls_encryption_key_format_versions "1";

    vod_drm_enabled on;
    vod_drm_request_uri "/udrm/system/ovp/$vod_suburi";

    vod_last_modified_types *;
    add_header Access-Control-Allow-Headers '*';
    add_header Access-Control-Expose-Headers 'Server,range,Content-Length,Content-Range';
    add_header Access-Control-Allow-Methods 'GET, HEAD, OPTIONS';
    add_header Access-Control-Allow-Origin '*';
    expires 100d;
}

Chiffrement commun HLS :

location ~ ^/cenchls/p/\d+/(sp/\d+/)?serveFlavor/entryId/([^/]+)/(.*) {
    vod hls;
    vod_hls_encryption_method sample-aes-cenc;
    vod_hls_encryption_key_format "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
    vod_hls_encryption_key_format_versions "1";

    vod_drm_enabled on;
    vod_drm_request_uri "/udrm/system/ovp/$vod_suburi";

    vod_last_modified_types *;
    add_header Access-Control-Allow-Headers '*';
    add_header Access-Control-Expose-Headers 'Server,range,Content-Length,Content-Range';
    add_header Access-Control-Allow-Methods 'GET, HEAD, OPTIONS';
    add_header Access-Control-Allow-Origin '*';
    expires 100d;
}

Configurations vérifiées

Voici une liste de configurations qui ont été testées et jugées fonctionnelles : * DASH/CENC avec PlayReady & Widevine PSSH ensemble * MSS PlayReady * HLS FairPlay

Recommandations de performance

Pour des déploiements de taille moyenne/grande, ne faites pas jouer les vidéos directement depuis le module nginx-vod-module. Étant donné que tous les différents protocoles de streaming supportés par nginx vod sont basés sur HTTP, ils peuvent être mis en cache par des proxies HTTP standard / CDNs. Pour une échelle moyenne, ajoutez une couche de proxies de mise en cache entre le module vod et les utilisateurs finaux (peut utiliser des serveurs nginx standard avec proxy_pass & proxy_cache). Pour des déploiements de grande échelle, il est recommandé d'utiliser un CDN (tel qu'Akamai, Level3, etc.).

En général, il est préférable d'avoir nginx vod aussi proche que possible de l'endroit où les fichiers mp4 sont stockés, et d'avoir les proxies de mise en cache aussi proches que possible des utilisateurs finaux. 2. Activez les caches du module nginx-vod-module : * vod_metadata_cache - évite la nécessité de relire les métadonnées vidéo pour chaque segment. Ce cache doit être assez grand, de l'ordre des Go. * vod_response_cache - sauvegarde les réponses des requêtes de manifeste. Ce cache peut ne pas être requis lors de l'utilisation d'une seconde couche de serveurs de mise en cache avant nginx vod. Aucune nécessité d'allouer un grand tampon pour ce cache, 128M est probablement plus que suffisant pour la plupart des déploiements. * vod_mapping_cache - uniquement pour le mode mappé, quelques Mo sont généralement suffisants. * open_file_cache de nginx - met en cache les descripteurs de fichiers ouverts.

Les ratios de réussite/échec de ces caches peuvent être suivis en activant les compteurs de performance (vod_performance_counters) et en configurant une page de statut pour nginx vod (vod_status) 3. En modes local et mappé, activez aio. - nginx doit être compilé avec le support aio, et cela doit être activé dans la conf nginx (aio on). Vous pouvez vérifier que cela fonctionne en regardant les compteurs de performance sur la page de statut vod - read_file (aio off) vs. async_read_file (aio on) 4. En modes local et mappé, activez l'ouverture de fichiers asynchrone - nginx doit être compilé avec le support des threads, et vod_open_file_thread_pool doit être spécifié dans nginx.conf. Vous pouvez vérifier que cela fonctionne en regardant les compteurs de performance sur la page de statut vod - open_file vs. async_open_file. Notez que open_file peut être non nul avec vod_open_file_thread_pool activé, en raison du cache de fichiers ouverts - les requêtes ouvertes qui sont servies à partir du cache seront comptées comme open_file synchrone. 5. Lors de l'utilisation de DASH/MSS activé DRM, si les fichiers vidéo ont un seul nalu par image, définissez vod_min_single_nalu_per_frame_segment sur une valeur non nulle. 6. Le surcoût de muxing des flux générés par ce module peut être réduit en modifiant les paramètres suivants : * HDS - définissez vod_hds_generate_moof_atom sur off * HLS - définissez vod_hls_mpegts_align_frames sur off et vod_hls_mpegts_interleave_frames sur on 7. Activez la compression gzip sur les réponses de manifeste -

gzip_types application/vnd.apple.mpegurl video/f4m application/dash+xml text/xml 8. Appliquez les meilleures pratiques de performance nginx courantes, telles que tcp_nodelay=on, client_header_timeout, etc.

Directives de configuration - de base

vod

syntaxe : vod segmenter
défaut : n/a
contexte : location

Active le module nginx-vod sur l'emplacement englobant. Les valeurs autorisées pour segmenter sont :

none - sert les fichiers MP4 tels quels / découpés
dash - Packager de streaming adaptatif dynamique sur HTTP
hds - Packager de streaming dynamique HTTP d'Adobe
hls - Packager de streaming en direct HTTP d'Apple
mss - Packager de streaming fluide de Microsoft
thumb - capture de vignettes
volume_map - carte de volume audio

vod_mode

syntaxe : vod_mode mode
défaut : local
contexte : http, server, location

Définit le mode d'accès aux fichiers - local, distant ou mappé (voir la section des fonctionnalités ci-dessus pour plus de détails)

vod_status

syntaxe : vod_status
défaut : n/a
contexte : location

Active la page de statut nginx-vod sur l'emplacement englobant. Les paramètres de requête suivants sont supportés : * ?reset=1 - réinitialise les compteurs de performance et les statistiques de cache. * ?format=prom - renvoie la sortie dans un format compatible avec Prometheus (le format par défaut est XML).

Directives de configuration - segmentation

vod_segment_duration

syntaxe : vod_segment_duration duration
défaut : 10s
contexte : http, server, location

Définit la durée du segment en millisecondes. Il est fortement recommandé d'utiliser une durée de segment qui est un multiple de la durée GOP. Si la durée du segment n'est pas un multiple de la durée GOP, et que vod_align_segments_to_key_frames est activé, il pourrait y avoir des différences significatives entre la durée du segment qui est rapportée dans le manifeste et la durée réelle du segment. Cela pourrait également conduire à l'apparition de segments vides dans le flux.

vod_live_window_duration

syntaxe : vod_live_window_duration duration
défaut : 30000
contexte : http, server, location

Définit la durée totale en millisecondes des segments qui doivent être retournés dans un manifeste en direct. Si la valeur est positive, nginx vod retourne une plage de maximum vod_live_window_duration millisecondes, se terminant à l'heure actuelle du serveur. Si la valeur est négative, nginx vod retourne une plage de maximum -vod_live_window_duration millisecondes à partir de la fin du JSON de mappage. Si la valeur est définie sur zéro, le manifeste en direct contiendra tous les segments qui sont entièrement contenus dans le cadre temporel du JSON de mappage.

vod_force_playlist_type_vod

syntaxe : vod_force_playlist_type_vod on/off
défaut : off
contexte : http, server, location

Générer un flux vod même lorsque l'ensemble multimédia a playlistType=live. L'activation de ce paramètre a les effets suivants : 1. Les horodatages des images seront continus et commenceront à zéro 2. Les index de segment commenceront à un 3. En cas de HLS, le manifeste retourné aura à la fois #EXT-X-PLAYLIST-TYPE:VOD et #EXT-X-ENDLIST

Cela peut être utile pour découper des sections vod d'un flux en direct.

vod_force_continuous_timestamps

syntaxe : vod_force_continuous_timestamps on/off
défaut : off
contexte : http, server, location

Générer des horodatages continus même lorsque l'ensemble multimédia a des lacunes (les lacunes peuvent être créées par l'utilisation de clipTimes) Si les horodatages ID3 sont activés (vod_hls_mpegts_output_id3_timestamps), ils contiennent les horodatages originaux qui ont été définis dans clipTimes.

vod_bootstrap_segment_durations

syntaxe : vod_bootstrap_segment_durations duration
défaut : none
contexte : http, server, location

Ajoute une durée de segment de démarrage en millisecondes. Ce paramètre peut être utilisé pour rendre les premiers segments plus courts que la durée de segment par défaut, permettant ainsi à la sélection de bitrate adaptatif de se déclencher plus tôt sans le surcoût de segments courts tout au long de la vidéo.

vod_align_segments_to_key_frames

syntaxe : vod_align_segments_to_key_frames on/off
défaut : off
contexte : http, server, location

Lorsqu'il est activé, le module force tous les segments à commencer par une image clé. Activer ce paramètre peut entraîner des différences entre les durées réelles des segments et les durées rapportées dans le manifeste (à moins que vod_manifest_segment_durations_mode ne soit défini sur accurate).

vod_segment_count_policy

syntaxe : vod_segment_count_policy last_short/last_long/last_rounded
défaut : last_short
contexte : http, server, location

Configure la politique de calcul du nombre de segments, pour segment_duration = 10 secondes : * last_short - un fichier de 33 sec est partitionné comme - 10, 10, 10, 3 * last_long - un fichier de 33 sec est partitionné comme - 10, 10, 13 * last_rounded - un fichier de 33 sec est partitionné comme - 10, 10, 13, un fichier de 38 sec est partitionné comme 10, 10, 10, 8

vod_manifest_duration_policy

syntaxe : vod_manifest_duration_policy min/max
défaut : max
contexte : http, server, location

Configure la politique de calcul de la durée d'un manifeste contenant plusieurs flux : * max - utilise la durée maximale du flux (par défaut) * min - utilise la durée minimale non nulle du flux

vod_manifest_segment_durations_mode

syntaxe : vod_manifest_segment_durations_mode estimate/accurate
défaut : estimate
contexte : http, server, location

Configure le mode de calcul des durées de segments dans les requêtes de manifeste : * estimate - rapporte la durée comme configurée dans nginx.conf, par exemple, si vod_segment_duration a la valeur 10000, un manifeste HLS contiendra #EXTINF:10 * accurate - rapporte la durée exacte du segment, en tenant compte des durées des images, par exemple, pour une fréquence d'images de 29.97 et des segments de 10 secondes, il rapportera le premier segment comme 10.01. le mode accurate prend également en compte l'alignement des images clés, au cas où vod_align_segments_to_key_frames serait activé

vod_media_set_override_json

syntaxe : vod_media_set_override_json json
défaut : {}
contexte : http, server, location

Ce paramètre fournit un moyen de remplacer des portions du JSON de l'ensemble multimédia (mode mappé uniquement). Par exemple, vod_media_set_override_json '{"clipTo":20000}' découpe l'ensemble multimédia à 20 sec. La valeur du paramètre peut contenir des variables.

Directives de configuration - en amont

vod_upstream_location

syntaxe : vod_upstream_location location
défaut : none
contexte : http, server, location

Définit un emplacement nginx qui est utilisé pour lire le fichier MP4 (mode distant) ou mapper l'URI de la requête (mode mappé).

vod_remote_upstream_location

syntaxe : vod_remote_upstream_location location
défaut : none
contexte : http, server, location

Définit un emplacement nginx qui est utilisé pour lire le fichier MP4 en mode distant ou mappé. Si cette directive est définie en mode mappé, le module lit les fichiers MP4 via HTTP, traitant les chemins dans le JSON de mappage comme des URIs (le comportement par défaut est de lire à partir de fichiers locaux)

vod_max_upstream_headers_size

syntaxe : vod_max_upstream_headers_size size
défaut : 4k
contexte : http, server, location

Définit la taille allouée pour contenir les en-têtes de réponse lors de l'émission de requêtes en amont (vers vod_xxx_upstream_location).

vod_upstream_extra_args

syntaxe : vod_upstream_extra_args "arg1=value1&arg2=value2&..."
défaut : vide
contexte : http, server, location

Arguments supplémentaires de chaîne de requête qui doivent être ajoutés à la requête en amont (modes distant/mappé uniquement). La valeur du paramètre peut contenir des variables.

vod_media_set_map_uri

syntaxe : vod_media_set_map_uri uri
défaut : $vod_suburi
contexte : http, server, location

Définit l'uri des requêtes de mappage de l'ensemble multimédia, la valeur du paramètre peut contenir des variables. Dans le cas d'URL multiples, $vod_suburi sera l'uri de sous-requête actuelle (une requête séparée est émise par sous URL)

vod_path_response_prefix

syntaxe : vod_path_response_prefix prefix
défaut : {"sequences":[{"clips":[{"type":"source","path":"
contexte : http, server, location

Définit le préfixe qui est attendu dans les réponses de mappage d'URI (mode mappé uniquement).

vod_path_response_postfix

syntaxe : vod_path_response_postfix postfix
défaut : "}]}]}
contexte : http, server, location

Définit le suffixe qui est attendu dans les réponses de mappage d'URI (mode mappé uniquement).

vod_max_mapping_response_size

syntaxe : vod_max_mapping_response_size length
défaut : 1K
contexte : http, server, location

Définit la longueur maximale d'un chemin retourné depuis l'amont (mode mappé uniquement).

Directives de configuration - secours

vod_fallback_upstream_location

syntaxe : vod_fallback_upstream_location location
défaut : none
contexte : http, server, location

Définit un emplacement nginx vers lequel la requête est redirigée après avoir rencontré une erreur de fichier non trouvé (modes local/mappé uniquement).

vod_proxy_header_name

syntaxe : vod_proxy_header_name name
défaut : X-Kaltura-Proxy
contexte : http, server, location

Définit le nom d'un en-tête HTTP qui est utilisé pour prévenir les boucles de proxy de secours (modes local/mappé uniquement).

vod_proxy_header_value

syntaxe : vod_proxy_header_value name
défaut : dumpApiRequest
contexte : http, server, location

Définit la valeur d'un en-tête HTTP qui est utilisé pour prévenir les boucles de proxy de secours (modes local/mappé uniquement).

Directives de configuration - performance

vod_metadata_cache

syntaxe : vod_metadata_cache zone_name zone_size [expiration]
défaut : off
contexte : http, server, location

Configure la taille et le nom de l'objet mémoire partagée du cache de métadonnées vidéo. Pour les fichiers MP4, ce cache contient l'atome moov.

vod_mapping_cache

syntaxe : vod_mapping_cache zone_name zone_size [expiration]
défaut : off
contexte : http, server, location

Configure la taille et le nom de l'objet mémoire partagée du cache de mappage pour vod (mode mappé uniquement).

vod_live_mapping_cache

syntaxe : vod_live_mapping_cache zone_name zone_size [expiration]
défaut : off
contexte : http, server, location

Configure la taille et le nom de l'objet mémoire partagée du cache de mappage pour les flux en direct (mode mappé uniquement).

vod_response_cache

syntaxe : vod_response_cache zone_name zone_size [expiration]
défaut : off
contexte : http, server, location

Configure la taille et le nom de l'objet mémoire partagée du cache de réponse. Le cache de réponse contient des manifestes et d'autres contenus non vidéo (comme le segment d'initialisation DASH, la clé de chiffrement HLS, etc.). Les segments vidéo ne sont pas mis en cache.

vod_live_response_cache

syntaxe : vod_live_response_cache zone_name zone_size [expiration]
défaut : off
contexte : http, server, location

Configure la taille et le nom de l'objet mémoire partagée du cache de réponse pour les réponses en direct changeant de temps. Ce cache contient les types de réponses suivants pour les flux en direct : DASH MPD, HLS index M3U8, HDS bootstrap, MSS manifest.

vod_initial_read_size

syntaxe : vod_initial_read_size size
défaut : 4K
contexte : http, server, location

Définit la taille de l'opération de lecture initiale du fichier MP4.

vod_max_metadata_size

syntaxe : vod_max_metadata_size size
défaut : 128MB
contexte : http, server, location

Définit la taille maximale de métadonnées vidéo supportée (pour MP4 - taille de l'atome moov)

vod_max_frames_size

syntaxe : vod_max_frames_size size
défaut : 16MB
contexte : http, server, location

Définit la limite sur la taille totale des images d'un seul segment

vod_max_frame_count

syntaxe : vod_max_frame_count count
défaut : 1048576
contexte : http, server, location

Définit la limite sur le nombre total d'images lues pour servir une requête non segmentée (par exemple, playlist).

vod_segment_max_frame_count

syntaxe : vod_segment_max_frame_count count
défaut : 65536
contexte : http, server, location

Définit la limite sur le nombre total d'images lues pour servir une requête de segment.

vod_cache_buffer_size

syntaxe : vod_cache_buffer_size size
défaut : 256K
contexte : http, server, location

Définit la taille des tampons de cache utilisés lors de la lecture des images MP4.

vod_open_file_thread_pool

syntaxe : vod_open_file_thread_pool pool_name
défaut : off
contexte : http, server, location

Active l'utilisation de l'ouverture de fichiers asynchrone via un pool de threads. Le pool de threads doit être défini avec une directive thread_pool, si aucun nom de pool n'est spécifié, le pool par défaut est utilisé. Cette directive est supportée uniquement sur nginx 1.7.11 ou plus récent lors de la compilation avec --add-threads. Remarque : cette directive désactive actuellement l'utilisation du cache de fichiers ouverts de nginx par le module nginx-vod-module

vod_output_buffer_pool

syntaxe : vod_output_buffer_pool size count
défaut : off
contexte : http, server, location

Préaloue des tampons pour générer des données de réponse, évitant ainsi la nécessité d'allouer/libérer les tampons à chaque requête.

vod_performance_counters

syntaxe : vod_performance_counters zone_name
défaut : off
contexte : http, server, location

Configure le nom de l'objet mémoire partagée des compteurs de performance

Directives de configuration - structure d'URL

vod_base_url

syntaxe : vod_base_url url
défaut : voir ci-dessous
contexte : http, server, location

Définit l'URL de base (schéma + domaine) qui doit être retournée dans les réponses de manifeste. La valeur du paramètre peut contenir des variables, si le paramètre évalue à une chaîne vide, des URLs relatives seront utilisées. Si le paramètre évalue à une chaîne se terminant par /, il est supposé être une URL complète - le module n'ajoute que le nom de fichier à cela, au lieu d'une URI complète. S'il n'est pas défini, l'URL de base est déterminée comme suit : 1. Si la requête ne contenait pas d'en-tête d'hôte (HTTP/1.0), des URLs relatives seront retournées 2. Sinon, l'URL de base sera $scheme://$http_host Le paramètre affecte actuellement uniquement HLS et DASH. Dans MSS et HDS, des URLs relatives sont toujours retournées.

vod_segments_base_url

syntaxe : vod_segments_base_url url
défaut : voir ci-dessous
contexte : http, server, location

Définit l'URL de base (schéma + domaine) qui doit être utilisée pour livrer les segments vidéo. La valeur du paramètre peut contenir des variables, si le paramètre évalue à une chaîne vide, des URLs relatives seront utilisées. Si non défini, vod_base_url sera utilisé. Le paramètre affecte actuellement uniquement HLS.

vod_multi_uri_suffix

syntaxe : vod_multi_uri_suffix suffix
défaut : .urlset
contexte : http, server, location

Un suffixe d'URL qui est utilisé pour identifier les URLs multiples. Une URL multiple est un moyen d'encoder plusieurs URLs différentes qui doivent être jouées ensemble comme un ensemble de streaming adaptatif, sous une seule URL. Lorsque le suffixe par défaut est utilisé, une URL d'ensemble HLS peut ressembler à : http://host/hls/common-prefix,bitrate1,bitrate2,common-suffix.urlset/master.m3u8

vod_clip_to_param_name

syntaxe : vod_clip_to_param_name name
défaut : clipTo
contexte : http, server, location

Le nom du paramètre de requête clip à demander.

vod_clip_from_param_name

syntaxe : vod_clip_from_param_name name
défaut : clipFrom
contexte : http, server, location

Le nom du paramètre de requête clip depuis.

vod_tracks_param_name

syntaxe : vod_tracks_param_name name
défaut : tracks
contexte : http, server, location

Le nom du paramètre de requête des pistes.

vod_time_shift_param_name

syntaxe : vod_time_shift_param_name name
défaut : shift
contexte : http, server, location

Le nom du paramètre de requête de décalage.

vod_speed_param_name

syntaxe : vod_speed_param_name name
défaut : speed
contexte : http, server, location

Le nom du paramètre de requête de vitesse.

vod_lang_param_name

syntaxe : vod_lang_param_name name
défaut : lang
contexte : http, server, location

Le nom du paramètre de requête de langue.

vod_force_sequence_index

syntaxe : vod_force_sequence_index on/off
défaut : off
contexte : http, server, location

Utiliser l'index de séquence dans les uris de segment même s'il n'y a qu'une seule séquence

Directives de configuration - en-têtes de réponse

vod_expires

syntaxe : vod_expires time
défaut : none
contexte : http, server, location

Définit la valeur des en-têtes de réponse "Expires" et "Cache-Control" pour les requêtes réussies. Cette directive est similaire à la directive expires intégrée de nginx, sauf qu'elle ne supporte que le scénario d'intervalle d'expiration (epoch, max, off, jour temps ne sont pas supportés) La principale motivation pour utiliser cette directive au lieu de la directive intégrée expires est d'avoir une expiration différente pour le contenu VOD et en direct dynamique. Si cette directive n'est pas spécifiée, le module nginx-vod-module ne définira pas les en-têtes "Expires" / "Cache-Control". Ce paramètre affecte tous les types de requêtes dans les playlists VOD et les requêtes de segment dans les playlists en direct.

vod_expires_live

syntaxe : vod_expires_live time
défaut : none
contexte : http, server, location

Identique à vod_expires (ci-dessus) pour les requêtes en direct qui ne sont pas dépendantes du temps et ne sont pas des segments (par exemple, HLS - master.m3u8, HDS - manifest.f4m).

vod_expires_live_time_dependent

syntaxe : vod_expires_live_time_dependent time
défaut : none
contexte : http, server, location

Identique à vod_expires (ci-dessus) pour les requêtes en direct qui sont dépendantes du temps (HLS - index.m3u8, HDS - bootstrap.abst, MSS - manifest, DASH - manifest.mpd).

vod_last_modified

syntaxe : vod_last_modified time
défaut : none
contexte : http, server, location

Définit la valeur de l'en-tête Last-Modified retourné dans la réponse, par défaut le module ne renvoie pas d'en-tête Last-Modified. La raison d'avoir ce paramètre ici est de supporter If-Modified-Since / If-Unmodified-Since. Étant donné que le module intégré ngx_http_not_modified_filter_module s'exécute avant tout autre module de filtre d'en-tête, il ne verra aucun en-tête défini par add_headers / more_set_headers. Cela fait que nginx répond toujours comme si le contenu avait changé (412 pour If-Unmodified-Since / 200 pour If-Modified-Since) Pour les requêtes en direct qui ne sont pas des segments (par exemple, live DASH MPD), Last-Modified est défini sur l'heure actuelle du serveur.

vod_last_modified_types

syntaxe : vod_last_modified_types mime-type1 mime-type2 ...
défaut : none
contexte : http, server, location

Définit les types MIME pour lesquels l'en-tête Last-Modified doit être défini. La valeur spéciale "*" correspond à tout type MIME.

Directives de configuration - montage publicitaire (mode mappé uniquement)

vod_dynamic_mapping_cache

syntaxe : vod_dynamic_mapping_cache zone_name zone_size [expiration]
défaut : off *