vod: Empacotador VOD baseado em NGINX

Instalação

Você pode instalar este módulo em qualquer distribuição baseada em RHEL, incluindo, mas não se limitando a:

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

CentOS/RHEL 8+, Fedora Linux, Amazon Linux 2023+CentOS/RHEL 7 e Amazon Linux 2

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

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

Ative o módulo adicionando o seguinte no topo de /etc/nginx/nginx.conf:

load_module modules/ngx_http_vod_module.so;

Este documento descreve o nginx-module-vod v1.33 lançado em 01 de janeiro de 2024.

nginx-vod-module

Participe da lista de organizações que utilizam este projeto de empacotador de vídeo.

Para streaming de vídeo ao vivo, utilize Media-Framework.

Recursos

Reempacotamento em tempo real de arquivos MP4 para DASH, HDS, HLS, MSS
Modos de operação:
Local - serve arquivos acessíveis localmente (disco local/NFS montado)
Remoto - serve arquivos acessíveis via HTTP usando requisições de intervalo
Mapeado - serve arquivos de acordo com uma especificação codificada em formato JSON. O JSON pode ser obtido de um servidor remoto ou lido de um arquivo local
Suporte a bitrate adaptativo
Suporte a playlists (tocando vários arquivos de mídia diferentes um após o outro) - apenas no modo mapeado
Suporte a simulação de ao vivo (gerando um stream ao vivo a partir de arquivos MP4) - apenas no modo mapeado
Suporte a fallback para arquivos não encontrados nos modos local/mapeado (útil em ambientes de múltiplos data centers)
Codecs de vídeo: H264, H265 (DASH/HLS), AV1 (DASH/HLS), VP8 (DASH), VP9 (DASH)
Codecs de áudio: AAC, MP3 (HLS/HDS/MSS), AC-3 (DASH/HLS), E-AC-3 (DASH/HLS), VORBIS (DASH), OPUS (DASH), FLAC (HLS), DTS (HLS)
Suporte a legendas -

Entrada: 1. WebVTT 2. SRT 3. DFXP/TTML 4. CAP (Cheetah)

Saída: 1. DASH - seja um único WebVTT ou segmentos SMPTE-TT (configurável) 2. HLS - WebVTT segmentado (m3u8) 3. MSS - convertido para TTML e empacotado em MP4 fragmentado (sem suporte para estilização)

Arquivos apenas de áudio/apenas de vídeo
Versões de áudio alternativas - suportando ambos:
Geração de manifesto com diferentes versões de áudio, permitindo seleção no lado do cliente
Muxing de streams de áudio e vídeo de arquivos/trilhas separadas - fornece a capacidade para servir diferentes versões de áudio de um único vídeo, sem a necessidade de suporte especial no lado do cliente.
Seleção de trilhas para arquivos MP4 de áudio/vídeo múltiplos
Mudança na taxa de reprodução - 0.5x até 2x (requer libavcodec e libavfilter)
Recorte de arquivos de origem (apenas de I-Frame para P-frame)
Suporte a comprimentos de segmento variáveis - permitindo que o player selecione o bitrate ótimo rapidamente, sem a sobrecarga de segmentos curtos durante toda a duração do vídeo
Recorte de arquivos MP4 para reprodução de download progressivo
Captura de miniaturas (requer libavcodec) e redimensionamento (requer libswscale)
Mapa de volume (requer libavcodec) - retorna um CSV contendo o nível de volume em cada intervalo
Descriptografia de arquivos MP4 criptografados com CENC (é possível criar tais arquivos com MP4Box)
DASH: suporte a criptografia comum (CENC)
MSS: suporte a criptografia PlayReady
HLS: Geração de playlist de I-frames (EXT-X-I-FRAMES-ONLY)
HLS: suporte a criptografia AES-128 / SAMPLE-AES

Limitações

Seleção de trilhas e mudança na taxa de reprodução não são suportadas em download progressivo
Geração de playlist de I-frames não é suportada quando a criptografia está habilitada
Testado apenas em Linux

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

yum install kaltura-nginx

#### Pacote deb do Debian/Ubuntu
*Nota para o Ubuntu: antes de tentar instalar o kaltura-nginx, você também deve garantir que o repositório multiverse esteja habilitado*

Para Debian Wheezy [7], Debian Jessie [8], Ubuntu 14.04 e 14.10, adicione este repositório:
```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

Para Ubuntu 16.04, 16.10 adicione este repositório:

## 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

Para Ubuntu 20.04 adicione este repositório:

## 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

Em seguida, instale o pacote kaltura-nginx:

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

Se você deseja utilizar os seguintes recursos: - Captura de miniaturas - Mudança na taxa de reprodução - 0.5x até 2x

Você também precisará instalar o pacote kaltura-ffmpeg (>= 3.1).

Estrutura de URL

Estrutura básica de URL

A estrutura básica de uma URL do nginx-vod-module é: http://<domínio>/<localização>/<fileuri>/<nome-do-arquivo>

Onde: * domínio - o domínio do servidor nginx-vod-module * localização - a localização especificada na configuração do nginx * fileuri - um URI para o arquivo mp4: * modo local - o caminho completo do arquivo é determinado de acordo com as diretivas root / alias do nginx.conf * modo mapeado - o caminho completo do arquivo é determinado de acordo com o JSON recebido do upstream / arquivo local * modo remoto - o arquivo mp4 é lido do upstream em partes * Nota: nos modos mapeado e remoto, a URL da requisição upstream é http://<upstream>/<localização>/<fileuri>?<extraargs> (extraargs é determinado pelo parâmetro vod_upstream_extra_args) * nome-do-arquivo - detalhado abaixo

Estrutura de Multi URL

Multi URLs são usadas para codificar várias URLs em uma única URL. Uma multi URL pode ser usada para especificar as URLs de vários arquivos MP4 diferentes que devem ser incluídos juntos em um MPD DASH, por exemplo.

A estrutura de uma multi URL é: http://<domínio>/<localização>/<prefixo>,<meio1>,<meio2>,<meio3>,<postfix>.urlset/<nome-do-arquivo>

A URL de exemplo acima representa 3 URLs: * http://<domínio>/<localização>/<prefixo><meio1><postfix>/<nome-do-arquivo> * http://<domínio>/<localização>/<prefixo><meio2><postfix>/<nome-do-arquivo> * http://<domínio>/<localização>/<prefixo><meio3><postfix>/<nome-do-arquivo>

O sufixo .urlset (pode ser alterado usando vod_multi_uri_suffix) indica que a URL deve ser tratada como uma multi URL. Por exemplo - a URL http://example.com/hls/videos/big_buck_bunny_,6,9,15,00k.mp4.urlset/master.m3u8 retornará um manifesto contendo: * 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

Parâmetros de caminho da URL

Os seguintes parâmetros são suportados no caminho da URL: * clipFrom - um deslocamento em milissegundos desde o início do vídeo, onde o stream gerado deve começar. Por exemplo, .../clipFrom/10000/... gerará um stream que começa 10 segundos após o início do vídeo. * clipTo - um deslocamento em milissegundos desde o início do vídeo, onde o stream gerado deve terminar. Por exemplo, .../clipTo/60000/... gerará um stream truncado a 60 segundos. * tracks - pode ser usado para selecionar trilhas de áudio/vídeo específicas. A estrutura do parâmetro é: v<id1>-v<id2>-a<id1>-a<id2>... Por exemplo, .../tracks/v1-a1/... selecionará a primeira trilha de vídeo e a primeira trilha de áudio. O padrão é incluir todas as trilhas. * shift - pode ser usado para aplicar um deslocamento de tempo a um ou mais streams. A estrutura do parâmetro é: v<vshift>-a<ashift>-s<sshift> Por exemplo, .../shift/v100/... aplicará um deslocamento para frente de 100ms aos timestamps de vídeo.

Estrutura do nome do arquivo

A estrutura do nome do arquivo é: <basename>[<seqparams>][<fileparams>][<trackparams>][<langparams>].<extension>

Onde: * basename + extension - o conjunto de opções é específico do empacotador (a lista abaixo se aplica às configurações padrão): * dash - manifest.mpd * hds - manifest.f4m * playlist mestre hls - master.m3u8 * playlist de mídia hls - index.m3u8 * mss - manifest * thumb - thumb-<offset>[<resizeparams>].jpg (offset é o deslocamento do vídeo da miniatura em milissegundos) * volume_map - volume_map.csv * seqparams - pode ser usado para selecionar sequências específicas por id (fornecido no JSON de mapeamento), e.g. master-sseq1.m3u8. * fileparams - pode ser usado para selecionar sequências específicas por índice ao usar multi URLs. Por exemplo, manifest-f1.mpd retornará um MPD apenas da primeira URL. * trackparams - pode ser usado para selecionar trilhas de áudio/vídeo específicas. Por exemplo, manifest-a1.f4m retornará um F4M contendo apenas o primeiro stream de áudio de cada sequência. O padrão é incluir as primeiras trilhas de áudio e vídeo de cada arquivo. As trilhas selecionadas no nome do arquivo são AND-ed com as trilhas selecionadas com o parâmetro de caminho /tracks/. v0/a0 seleciona todas as trilhas de vídeo/áudio, respectivamente. Os parâmetros a/v podem ser combinados com f/s, e.g. f1-v1-f2-a1 = vídeo1 do arquivo1 + áudio1 do arquivo2, f1-f2-v1 = vídeo1 do arquivo1 + vídeo1 do arquivo2. * langparams - pode ser usado para filtrar trilhas de áudio/legendas de acordo com seu idioma (código ISO639-3). Por exemplo, master-leng.m3u8 retornará apenas trilhas de áudio em inglês. * resizeparams - pode ser usado para redimensionar a imagem da miniatura retornada. Por exemplo, thumb-1000-w150-h100.jpg captura uma miniatura 1 segundo após o início do vídeo e a redimensiona para 150x100. Se uma das dimensões for omitida, seu valor é definido para que a imagem resultante mantenha a proporção do quadro do vídeo.

Formato de resposta de mapeamento

Quando configurado para rodar em modo mapeado, o nginx-vod-module emite uma requisição HTTP para um servidor upstream configurado a fim de receber o layout dos streams de mídia que deve gerar. A resposta deve estar em formato JSON.

Esta seção contém alguns exemplos simples seguidos de uma referência dos objetos e campos suportados. Mas primeiro, algumas definições:

Source Clip - um conjunto de quadros de áudio e/ou vídeo (trilhas) extraídos de um único arquivo de mídia
Generator - um componente que pode gerar quadros de áudio/vídeo. Atualmente, o único gerador suportado é o gerador de silêncio.
Filter - uma manipulação que pode ser aplicada em quadros de áudio/vídeo. Os seguintes filtros são suportados:
mudança de taxa (velocidade) - aplica-se tanto a áudio quanto a vídeo
mudança de volume de áudio
mix - pode ser usado para mesclar várias trilhas de áudio, ou para mesclar o áudio da fonte A com o vídeo da fonte B
Clip - o resultado da aplicação de zero ou mais filtros em um conjunto de clips de origem
Dynamic Clip - um clip cujo conteúdo não é conhecido antecipadamente, e.g. conteúdo publicitário direcionado
Sequence - um conjunto de clips que devem ser reproduzidos um após o outro.
Set - várias sequências que tocam juntas como um conjunto adaptativo, cada sequência deve ter o mesmo número de clips.

Mapeamento simples

O JSON abaixo mapeia a URI da requisição para um único arquivo MP4:

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

Ao usar multi URLs, este é o único padrão JSON permitido. Em outras palavras, não é possível combinar JSONs mais complexos usando multi URL.

Conjunto adaptativo

Como alternativa ao uso de multi URL, um conjunto adaptativo pode ser definido via JSON:

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

Playlist

O JSON abaixo tocará 35 segundos do vídeo1 seguido por 22 segundos do vídeo2:

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

Filtros

O JSON abaixo pega o vídeo1, toca-o a x1.5 e mistura o áudio do resultado com o áudio do vídeo2, após reduzi-lo a 50% do 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"
                            }
                        }
                    ]
                }
            ]
        }
    ]
}

Ao vivo contínuo

O JSON abaixo é um exemplo de um stream ao vivo contínuo (=um stream ao vivo em que todos os vídeos têm exatamente os mesmos parâmetros de codificação). Na prática, este JSON terá que ser gerado por algum script, uma vez que é dependente do tempo. (veja test/playlist.php para uma implementação de exemplo)

{
    "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"
                }
            ]
        }
    ]
}

Ao vivo não contínuo

O JSON abaixo é um exemplo de um stream ao vivo não contínuo (=um stream ao vivo em que os vídeos têm diferentes parâmetros de codificação). Na prática, este JSON terá que ser gerado por algum script, uma vez que é dependente do tempo (veja test/playlist.php para uma implementação de exemplo)

{
    "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"
                }
            ]
        }
    ]
}

Referência de mapeamento

Set (objeto de nível superior no JSON de mapeamento)

Campos obrigatórios: * sequences - array de objetos Sequence. O mapeamento deve conter pelo menos uma sequência e até 32 sequências.

Campos opcionais: * id - uma string que identifica o conjunto. O id pode ser recuperado por $vod_set_id. * playlistType - string, pode ser definida como live, vod ou event (apenas suportado para playlists HLS), o padrão é vod. * durations - um array de inteiros representando as durações dos clips em milissegundos. Este campo é obrigatório se o mapeamento contém mais de um único clip por sequência. Se especificado, este array deve conter pelo menos um elemento e até 128 elementos. * discontinuity - booleano, indica se os diferentes clips em cada sequência têm diferentes parâmetros de mídia. Este campo tem diferentes manifestações de acordo com o protocolo de entrega - um valor de verdadeiro gerará #EXT-X-DISCONTINUITY em HLS, e um MPD de múltiplos períodos em DASH. O valor padrão é verdadeiro, definido como falso apenas se os arquivos de mídia foram transcodificados com exatamente os mesmos parâmetros (em AVC, por exemplo, os clips devem ter exatamente o mesmo SPS/PPS). * segmentDuration - inteiro, define a duração do segmento em milissegundos. Este campo, se especificado, tem prioridade sobre o valor definido em vod_segment_duration. * consistentSequenceMediaInfo - booleano, atualmente afeta apenas DASH. Quando definido como verdadeiro (padrão) o MPD relatará os mesmos parâmetros de mídia em cada elemento de período. Definir como falso pode ter implicações severas de desempenho para longas sequências (nginx-vod-module tem que ler as informações de mídia de todos os clips incluídos no mapeamento para gerar o MPD) * referenceClipIndex - inteiro, define o índice (baseado em 1) do clip que deve ser usado para recuperar os metadados de vídeo para requisições de manifesto (codec, largura, altura etc.) Se consistentSequenceMediaInfo estiver definido como falso, este parâmetro não tem efeito - todos os clips são analisados. Se este parâmetro não for especificado, o nginx-vod-module usa o último clip por padrão. * notifications - array de objetos de notificação (veja abaixo), quando um segmento é solicitado, todas as notificações que caem entre os tempos de início/fim do segmento são acionadas. as notificações devem ser ordenadas em uma ordem de deslocamento crescente. * clipFrom - inteiro, contém um timestamp indicando onde o stream retornado deve começar. Definir este parâmetro é equivalente a passar /clipFrom/ na URL. * clipTo - inteiro, contém um timestamp indicando onde o stream retornado deve terminar. Definir este parâmetro é equivalente a passar /clipTo/ na URL. * cache - booleano, se definido como falso, a resposta do mapeamento não será salva em cache (vod_mapping_cache). O valor padrão é verdadeiro. * closedCaptions - array de objetos de legendas ocultas (veja abaixo), contendo idiomas e ids de quaisquer legendas CEA-608 / CEA-708 incorporadas. Se um array vazio for fornecido, o módulo irá gerar CLOSED-CAPTIONS=NONE em cada tag EXT-X-STREAM-INF. Se a lista não aparecer no JSON, o módulo não irá gerar nenhum campo CLOSED-CAPTIONS na playlist.

Campos ao vivo: * firstClipTime - inteiro, obrigatório para todas as playlists ao vivo, a menos que clipTimes seja especificado. Contém o tempo absoluto do primeiro clip na playlist, em milissegundos desde a época (unixtime x 1000) * clipTimes - array de inteiros, define o tempo absoluto de todos os clips na playlist, em milissegundos desde a época (unixtime x 1000). Este campo pode ser usado apenas quando discontinuity estiver definido como verdadeiro. Os timestamps podem conter lacunas, mas não são permitidos sobreposições (clipTimes[n + 1] >= clipTimes[n] + durations[n]) * segmentBaseTime - inteiro, obrigatório para streams ao vivo contínuos, contém o tempo absoluto do primeiro segmento do stream, em milissegundos desde a época (unixtime x 1000). Este valor não deve mudar durante a reprodução. Para streams ao vivo não contínuos, este campo é opcional: * se não definido, índices de segmentos sequenciais serão usados ao longo da playlist. Neste caso, o servidor upstream que gera o JSON de mapeamento deve manter o estado, e atualizar initialSegmentIndex toda vez que um clip é removido da playlist. * se definido, as lacunas de tempo entre clips não devem ser menores que vod_segment_duration. * firstClipStartOffset - inteiro, opcional, medido em milissegundos. Este campo contém a diferença entre o tempo do primeiro clip e o tempo de início original do primeiro clip - o tempo que ele tinha quando foi adicionado inicialmente (antes da janela ao vivo se mover) * initialClipIndex - inteiro, obrigatório para streams ao vivo não contínuos que misturam vídeos com diferentes parâmetros de codificação (SPS/PPS), contém o índice do primeiro clip na playlist. Sempre que um clip é removido do início da playlist, este valor deve ser incrementado em um. * initialSegmentIndex - inteiro, obrigatório para streams ao vivo que não definem segmentBaseTime, contém o índice do primeiro segmento na playlist. Sempre que um clip é removido do início da playlist, este valor deve ser incrementado pelo número de segmentos no clip. * presentationEndTime - inteiro, opcional, medido em milissegundos desde a época. quando fornecido, o módulo irá comparar o tempo atual com o valor fornecido, e sinalizar o fim da apresentação ao vivo se presentationEndTime tiver passado. No HLS, por exemplo, este parâmetro controla se uma tag #EXT-X-ENDLIST deve ser incluída na playlist de mídia. Quando o parâmetro não é fornecido, o módulo não sinalizará o fim da apresentação ao vivo. * expirationTime - inteiro, opcional, medido em milissegundos desde a época. quando fornecido, o módulo irá comparar o tempo atual com o valor fornecido, e se expirationTime tiver passado, o módulo retornará um erro 404 para requisições de manifesto (as requisições de segmento continuarão a ser atendidas). quando tanto presentationEndTime quanto expirationTime tiverem passado, presentationEndTime tem prioridade, ou seja, requisições de manifesto serão atendidas e sinalizarão o fim da apresentação. * liveWindowDuration - inteiro, opcional, fornece uma maneira de substituir vod_live_window_duration especificado na configuração. Se o valor exceder o valor absoluto especificado em vod_live_window_duration, ele é ignorado. * timeOffset - inteiro, define um deslocamento que deve ser aplicado ao relógio do servidor ao atender requisições ao vivo. Este parâmetro pode ser usado para testar eventos futuros/passados.

Sequência

Campos obrigatórios: * clips - array de objetos Clip (obrigatório). O número de elementos deve corresponder ao número do array de durações especificado no conjunto. Se o array de durações não for especificado, o array de clips deve conter um único elemento.

Campos opcionais: * id - uma string que identifica a sequência. O id pode ser recuperado por $vod_sequence_id. * language - um código de idioma de 3 letras (ISO-639-2), este campo tem prioridade sobre qualquer idioma especificado no arquivo de mídia (átomo mp4 mdhd) * label - uma string amigável que identifica a sequência. Se um idioma for especificado, um rótulo padrão será automaticamente derivado dele - e.g. se o idioma for ita, por padrão italiano será usado como rótulo. * bitrate - um objeto que pode ser usado para definir o bitrate para os diferentes tipos de mídia, em bits por segundo. Por exemplo, {"v": 900000, "a": 64000}. Se o bitrate não for fornecido, o nginx-vod-module irá estimá-lo com base no último clip da sequência. * avg_bitrate - um objeto que pode ser usado para definir o bitrate médio para os diferentes tipos de mídia, em bits por segundo. Veja bitrate acima para um objeto de exemplo. Se especificado, o módulo usará o valor para preencher o atributo AVERAGE-BANDWIDTH de #EXT-X-STREAM-INF em HLS.

Clip (abstrato)

Campos obrigatórios: * type - uma string que define o tipo do clip. Valores permitidos são: * source * rateFilter * mixFilter * gainFilter * silence * concat * dynamic

Campos opcionais: * keyFrameDurations - array de inteiros, contendo as durações em milissegundos dos quadros chave de vídeo no clip. Esta propriedade só pode ser fornecida nos clips de nível superior de cada sequência, fornecer esta propriedade em clips aninhados não tem efeito. Fornecer as durações dos quadros chave permite que o módulo: 1. alinhe os segmentos aos quadros chave 2. relate as durações corretas dos segmentos no manifesto - fornecendo uma alternativa para definir vod_manifest_segment_durations_mode como accurate, que não é suportado para conjuntos de mídia de múltiplos clips (por razões de desempenho). * firstKeyFrameOffset - inteiro, deslocamento do primeiro quadro chave de vídeo no clip, medido em milissegundos em relação a firstClipTime. O padrão é 0 se não fornecido.

Clip de origem

Campos obrigatórios: * type - uma string com o valor source * path - uma string contendo o caminho do arquivo MP4. A string "empty" pode ser usada para representar um arquivo de legendas vazio (útil caso apenas alguns vídeos em uma playlist tenham legendas)

Campos opcionais: * id - uma string que identifica o clip de origem * sourceType - define a interface que deve ser usada para ler o arquivo MP4, valores permitidos são: file e http. Por padrão, o módulo usa http se vod_remote_upstream_location estiver definido, e file caso contrário. * tracks - uma string que especifica as trilhas que devem ser usadas, o padrão é "v1-a1", o que significa a primeira trilha de vídeo e a primeira trilha de áudio * clipFrom - um inteiro que especifica um deslocamento em milissegundos, a partir do início do arquivo de mídia, a partir do qual começar a carregar quadros * encryptionKey - uma string codificada em base64 contendo a chave (128/192/256 bits) que deve ser usada para descriptografar o arquivo. * encryptionIv - uma string codificada em base64 contendo o iv (128 bits) que deve ser usado para descriptografar o arquivo. * encryptionScheme - o esquema de criptografia que foi usado para criptografar o arquivo. Atualmente, apenas dois esquemas são suportados - cenc para arquivos MP4, aes-cbc para arquivos de legendas.

Clip de filtro de taxa

Campos obrigatórios: * type - uma string com o valor rateFilter * rate - um float que especifica o fator de aceleração, e.g. um valor de 2 significa o dobro da velocidade. Valores permitidos estão na faixa de 0.5 - 2 com até dois pontos decimais * source - um objeto clip sobre o qual realizar o filtro de taxa

Clip de filtro de ganho

Campos obrigatórios: * type - uma string com o valor gainFilter * gain - um float que especifica o fator de amplificação, e.g. um valor de 2 significa duas vezes mais alto. O ganho deve ser positivo com até dois pontos decimais * source - um objeto clip sobre o qual realizar o filtro de ganho

Clip de filtro de mistura

Campos obrigatórios: * type - uma string com o valor mixFilter * sources - um array de objetos Clip para misturar. Este array deve conter pelo menos um clip e até 32 clips.

Clip de concatenação

Campos obrigatórios: * type - uma string com o valor concat * durations - um array de inteiros representando durações MP4 em milissegundos, este array deve corresponder ao array paths em contagem e ordem.

Campos opcionais: * paths - um array de strings, contendo os caminhos dos arquivos MP4. Ou paths ou clipIds devem ser especificados. * clipIds - um array de strings, contendo os ids dos clips de origem. Os ids são traduzidos para caminhos emitindo uma requisição para a uri especificada em vod_source_clip_map_uri. Ou paths ou clipIds devem ser especificados. * tracks - uma string que especifica as trilhas que devem ser usadas, o padrão é "v1-a1", o que significa a primeira trilha de vídeo e a primeira trilha de áudio * offset - um inteiro em milissegundos que indica o timestamp de deslocamento do primeiro quadro no stream concatenado em relação ao tempo de início do clip * basePath - uma string que deve ser adicionada como um prefixo a todos os caminhos * notifications - array de objetos de notificação (veja abaixo), quando um segmento é solicitado, todas as notificações que caem entre os tempos de início/fim do segmento são acionadas. as notificações devem ser ordenadas em uma ordem de deslocamento crescente.

Clip dinâmico

Campos obrigatórios: * type - uma string com o valor dynamic * id - uma string que identifica exclusivamente o clip dinâmico, usada para mapear o clip ao seu conteúdo

Notificação

Campos obrigatórios: * offset - um inteiro em milissegundos que indica o tempo em que a notificação deve ser acionada. quando o objeto de notificação está contido no conjunto de mídia, offset é relativo a firstClipTime (0 para vod). quando o objeto de notificação está contido em um clip de concatenação, offset é relativo ao início do clip de concatenação. * id - uma string que identifica a notificação, este id pode ser referenciado por vod_notification_uri usando a variável $vod_notification_id

Legendas ocultas

Campos obrigatórios: * id - uma string que identifica as legendas incorporadas. Isso se tornará o campo INSTREAM-ID e deve ter um dos seguintes valores: CC1, CC3, CC3, CC4, ou SERVICEn, onde n está entre 1 e 63. * label - uma string amigável que indica o idioma da trilha de legendas ocultas.

Campos opcionais: * language - um código de idioma de 3 letras (ISO-639-2) que indica o idioma da trilha de legendas ocultas.

Segurança

Criptografia de URL

Como alternativa à tokenização, a criptografia de URL pode ser usada para impedir que um atacante consiga criar uma URL reproduzível. A criptografia de URL pode ser implementada com https://github.com/kaltura/nginx-secure-token-module, e é suportada para HLS e DASH (com formato de manifesto definido como segmentlist).

Em termos de segurança, a principal vantagem dos tokens CDN sobre a criptografia de URL é que os tokens CDN geralmente expiram, enquanto URLs criptografadas não (alguém que obtém uma URL reproduzível poderá usá-la indefinidamente)

Criptografia de mídia

O nginx-vod-module suporta esquemas de criptografia HLS AES-128 e SAMPLE-AES. A principal diferença entre a criptografia de mídia e DRM (detalhada abaixo) é o mecanismo usado para transferir a chave de criptografia para o cliente. Com a criptografia de mídia, a chave é buscada pelo cliente realizando uma simples requisição GET para o nginx-vod-module, enquanto com DRM a chave é retornada dentro de uma resposta de licença específica do fornecedor.

A criptografia de mídia reduz o problema de proteger a mídia à necessidade de proteger a chave de criptografia. As URLs dos segmentos de mídia (que compõem a vasta maioria do tráfego) podem ser completamente desprotegidas, e facilmente armazenáveis em cache por quaisquer proxies entre o cliente e os servidores (diferente da tokenização). A requisição da chave de criptografia pode então ser protegida usando um dos métodos mencionados acima (tokens CDN, regras de acesso do nginx etc.).

Além disso, é possível configurar o nginx-vod-module para retornar a chave de criptografia via HTTPS enquanto os segmentos são entregues via HTTP. A maneira de configurar isso é definir vod_segments_base_url como http://nginx-vod-host e definir vod_base_url como https://nginx-vod-host.

DRM

O nginx-vod-module tem a capacidade de realizar criptografia em tempo real para MPEG DASH (CENC), MSS Play Ready e FairPlay HLS. Assim como no caso da criptografia de mídia, a criptografia é realizada enquanto serve um segmento de vídeo/áudio ao cliente, portanto, ao trabalhar com DRM, é recomendado não servir o conteúdo diretamente do nginx-vod-module para os usuários finais. Uma arquitetura mais escalável seria usar servidores proxy ou um CDN para armazenar em cache os segmentos criptografados.

Para realizar a criptografia, o nginx-vod-module precisa de vários parâmetros, incluindo key & key_id, esses parâmetros são buscados de um servidor externo via requisições HTTP GET. O parâmetro vod_drm_upstream_location especifica uma localização nginx que é usada para acessar o servidor DRM, e a URI da requisição é configurada usando vod_drm_request_uri (este parâmetro pode incluir variáveis do nginx). A resposta do servidor DRM é um JSON, com o seguinte formato:

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

pssh.data - dados binários codificados em base64, o formato desses dados é específico do fornecedor de DRM
pssh.uuid - o UUID do sistema DRM, neste caso, edef8ba9-79d6-4ace-a3c8-27dcd51d21ed representa Widevine
key - chave de criptografia codificada em base64 (128 bits)
key_id - identificador da chave codificado em base64 (128 bits)
iv - vetor de inicialização opcional codificado em base64 (128 bits). O IV é atualmente usado apenas em HLS (FairPlay), nos outros protocolos um IV é gerado automaticamente pelo nginx-vod-module.

Configurações de exemplo

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

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

Configurações verificadas

A seguir está uma lista de configurações que foram testadas e consideradas funcionais: * DASH/CENC com PlayReady & Widevine PSSH juntos * MSS PlayReady * HLS FairPlay

Recomendações de desempenho

Para implantações de médio/grande porte, não faça os usuários reproduzirem os vídeos diretamente do nginx-vod-module. Como todos os diferentes protocolos de streaming suportados pelo nginx vod são baseados em HTTP, eles podem ser armazenados em cache por proxies HTTP padrão / CDNs. Para escala média, adicione uma camada de proxies de cache entre o módulo vod e os usuários finais (pode usar servidores nginx padrão com proxy_pass & proxy_cache). Para implantações de grande escala, é recomendado usar um CDN (como Akamai, Level3 etc.).

Em geral, é melhor ter o nginx vod o mais próximo possível de onde os arquivos mp4 estão armazenados, e ter os proxies de cache o mais próximo possível dos usuários finais. 2. Habilite os caches do nginx-vod-module: * vod_metadata_cache - evita a necessidade de reler os metadados do vídeo para cada segmento. Este cache deve ser bastante grande, na ordem de GBs. * vod_response_cache - salva as respostas de requisições de manifesto. Este cache pode não ser necessário ao usar uma segunda camada de servidores de cache antes do nginx vod. Não é necessário alocar um buffer grande para este cache, 128M é provavelmente mais do que suficiente para a maioria das implantações. * vod_mapping_cache - apenas para modo mapeado, alguns MB geralmente são suficientes. * open_file_cache do nginx - armazena em cache handles de arquivos abertos.

As taxas de acerto/falha desses caches podem ser monitoradas habilitando contadores de desempenho (vod_performance_counters) e configurando uma página de status para o nginx vod (vod_status) 3. Nos modos local e mapeado, habilite aio. - o nginx deve ser compilado com suporte a aio, e deve ser habilitado na configuração do nginx (aio on). Você pode verificar se funciona olhando os contadores de desempenho na página de status do vod - read_file (aio off) vs. async_read_file (aio on) 4. Nos modos local e mapeado, habilite a abertura assíncrona de arquivos - o nginx deve ser compilado com suporte a threads, e vod_open_file_thread_pool deve ser especificado no nginx.conf. Você pode verificar se funciona olhando os contadores de desempenho na página de status do vod - open_file vs. async_open_file. Note que open_file pode ser não zero com vod_open_file_thread_pool habilitado, devido ao cache de arquivos abertos - requisições abertas que são atendidas a partir do cache serão contadas como open_file síncrono. 5. Ao usar DASH/MSS com DRM habilitado, se os arquivos de vídeo tiverem um único nalu por quadro, defina vod_min_single_nalu_per_frame_segment como não zero. 6. A sobrecarga de muxing dos streams gerados por este módulo pode ser reduzida alterando os seguintes parâmetros: * HDS - defina vod_hds_generate_moof_atom como off * HLS - defina vod_hls_mpegts_align_frames como off e vod_hls_mpegts_interleave_frames como on 7. Habilite a compressão gzip nas respostas de manifesto -

gzip_types application/vnd.apple.mpegurl video/f4m application/dash+xml text/xml 8. Aplique as melhores práticas comuns de desempenho do nginx, como tcp_nodelay=on, client_header_timeout etc.

Diretrizes de configuração - base

vod

syntax: vod segmenter
default: n/a
context: location

Habilita o módulo nginx-vod na localização que o envolve. Os valores permitidos para segmenter são:

none - serve os arquivos MP4 como estão / recortados
dash - Empacotador de Streaming Adaptativo Dinâmico sobre HTTP
hds - Empacotador de Streaming Dinâmico HTTP da Adobe
hls - Empacotador de Streaming Ao Vivo HTTP da Apple
mss - Empacotador de Streaming Suave da Microsoft
thumb - captura de miniatura
volume_map - mapa de volume de áudio

vod_mode

syntax: vod_mode mode
default: local
context: http, server, location

Define o modo de acesso ao arquivo - local, remoto ou mapeado (veja a seção de recursos acima para mais detalhes)

vod_status

syntax: vod_status
default: n/a
context: location

Habilita a página de status do nginx-vod na localização que a envolve. Os seguintes parâmetros de consulta são suportados: * ?reset=1 - redefine os contadores de desempenho e as estatísticas de cache. * ?format=prom - retorna a saída em formato compatível com Prometheus (o formato padrão é XML).

Diretrizes de configuração - segmentação

vod_segment_duration

syntax: vod_segment_duration duration
default: 10s
context: http, server, location

Define a duração do segmento em milissegundos. É altamente recomendável usar uma duração de segmento que seja um múltiplo da duração do GOP. Se a duração do segmento não for um múltiplo da duração do GOP, e vod_align_segments_to_key_frames estiver habilitado, pode haver diferenças significativas entre a duração do segmento que é relatada no manifesto e a duração real do segmento. Isso também pode levar à aparência de segmentos vazios dentro do stream.

vod_live_window_duration

syntax: vod_live_window_duration duration
default: 30000
context: http, server, location

Define a duração total em milissegundos dos segmentos que devem ser retornados em um manifesto ao vivo. Se o valor for positivo, o nginx vod retorna um intervalo máximo de vod_live_window_duration milissegundos, terminando no tempo atual do servidor. Se o valor for negativo, o nginx vod retorna um intervalo máximo de -vod_live_window_duration milissegundos a partir do final do JSON de mapeamento. Se o valor for definido como zero, o manifesto ao vivo conterá todos os segmentos que estão totalmente contidos na janela de tempo do JSON de mapeamento.

vod_force_playlist_type_vod

syntax: vod_force_playlist_type_vod on/off
default: off
context: http, server, location

Gera um stream vod mesmo quando o conjunto de mídia tem playlistType=live. Habilitar esta configuração tem os seguintes efeitos: 1. Os timestamps dos quadros serão contínuos e começarão do zero 2. Os índices dos segmentos começarão de um 3. Em caso de HLS, o manifesto retornado terá tanto #EXT-X-PLAYLIST-TYPE:VOD quanto #EXT-X-ENDLIST

Isso pode ser útil para recortar seções vod de um stream ao vivo.

vod_force_continuous_timestamps

syntax: vod_force_continuous_timestamps on/off
default: off
context: http, server, location

Gera timestamps contínuos mesmo quando o conjunto de mídia tem lacunas (lacunas podem ser criadas pelo uso de clipTimes) Se timestamps ID3 estiverem habilitados (vod_hls_mpegts_output_id3_timestamps), eles contêm os timestamps originais que foram definidos em clipTimes.

vod_bootstrap_segment_durations

syntax: vod_bootstrap_segment_durations duration
default: none
context: http, server, location

Adiciona uma duração de segmento de bootstrap em milissegundos. Esta configuração pode ser usada para fazer com que os primeiros segmentos sejam mais curtos do que a duração padrão do segmento, fazendo com que a seleção de bitrate adaptativa comece mais cedo sem a sobrecarga de segmentos curtos durante todo o vídeo.

vod_align_segments_to_key_frames

syntax: vod_align_segments_to_key_frames on/off
default: off
context: http, server, location

Quando habilitado, o módulo força todos os segmentos a começarem com um quadro chave. Habilitar esta configuração pode levar a diferenças entre as durações reais dos segmentos e as durações relatadas no manifesto (a menos que vod_manifest_segment_durations_mode esteja definido como preciso).

vod_segment_count_policy

syntax: vod_segment_count_policy last_short/last_long/last_rounded
default: last_short
context: http, server, location

Configura a política para calcular a contagem de segmentos, para segment_duration = 10 segundos: * last_short - um arquivo de 33 seg é particionado como - 10, 10, 10, 3 * last_long - um arquivo de 33 seg é particionado como - 10, 10, 13 * last_rounded - um arquivo de 33 seg é particionado como - 10, 10, 13, um arquivo de 38 seg é particionado como 10, 10, 10, 8

vod_manifest_duration_policy

syntax: vod_manifest_duration_policy min/max
default: max
context: http, server, location

Configura a política para calcular a duração de um manifesto contendo múltiplos streams: * max - usa a duração máxima do stream (padrão) * min - usa a duração mínima não zero do stream

vod_manifest_segment_durations_mode

syntax: vod_manifest_segment_durations_mode estimate/accurate
default: estimate
context: http, server, location

Configura o modo de cálculo das durações dos segmentos dentro das requisições de manifesto: * estimate - relata a duração conforme configurado no nginx.conf, e.g. se vod_segment_duration tiver o valor 10000, um manifesto HLS conterá #EXTINF:10 * accurate - relata a duração exata do segmento, levando em conta as durações dos quadros, e.g. para uma taxa de quadros de 29.97 e segmentos de 10 segundos, relatará o primeiro segmento como 10.01. o modo preciso também leva em conta o alinhamento dos quadros chave, caso vod_align_segments_to_key_frames esteja ativado

vod_media_set_override_json

syntax: vod_media_set_override_json json
default: {}
context: http, server, location

Este parâmetro fornece uma maneira de substituir partes do JSON do conjunto de mídia (apenas modo mapeado). Por exemplo, vod_media_set_override_json '{"clipTo":20000}' recorta o conjunto de mídia para 20 seg. O valor do parâmetro pode conter variáveis.

Diretrizes de configuração - upstream

vod_upstream_location

syntax: vod_upstream_location location
default: none
context: http, server, location

Define uma localização nginx que é usada para ler o arquivo MP4 (modo remoto) ou mapear a URI da requisição (modo mapeado).

vod_remote_upstream_location

syntax: vod_remote_upstream_location location
default: none
context: http, server, location

Define uma localização nginx que é usada para ler o arquivo MP4 no modo remoto ou mapeado. Se esta diretiva estiver definida no modo mapeado, o módulo lê os arquivos MP4 via HTTP, tratando os caminhos no JSON de mapeamento como URIs (o comportamento padrão é ler de arquivos locais)

vod_max_upstream_headers_size

syntax: vod_max_upstream_headers_size size
default: 4k
context: http, server, location

Define o tamanho alocado para armazenar os cabeçalhos de resposta ao emitir requisições upstream (para vod_xxx_upstream_location).

vod_upstream_extra_args

syntax: vod_upstream_extra_args "arg1=value1&arg2=value2&..."
default: empty
context: http, server, location

Argumentos adicionais da string de consulta que devem ser adicionados à requisição upstream (modos remoto/mapeado apenas). O valor do parâmetro pode conter variáveis.

vod_media_set_map_uri

syntax: vod_media_set_map_uri uri
default: $vod_suburi
context: http, server, location

Define a uri das requisições de mapeamento do conjunto de mídia, o valor do parâmetro pode conter variáveis. No caso de multi url, $vod_suburi será a sub uri atual (uma requisição separada é emitida por sub URL)

vod_path_response_prefix

syntax: vod_path_response_prefix prefix
default: {"sequences":[{"clips":[{"type":"source","path":"
context: http, server, location

Define o prefixo que é esperado nas respostas de mapeamento de URI (apenas modo mapeado).

vod_path_response_postfix

syntax: vod_path_response_postfix postfix
default: "}]}]}
context: http, server, location

Define o sufixo que é esperado nas respostas de mapeamento de URI (apenas modo mapeado).

vod_max_mapping_response_size

syntax: vod_max_mapping_response_size length
default: 1K
context: http, server, location

Define o tamanho máximo de um caminho retornado do upstream (apenas modo mapeado).

Diretrizes de configuração - fallback

vod_fallback_upstream_location

syntax: vod_fallback_upstream_location location
default: none
context: http, server, location

Define uma localização nginx para a qual a requisição é encaminhada após encontrar um erro de arquivo não encontrado (modos local/mapeado apenas).

vod_proxy_header_name

syntax: vod_proxy_header_name name
default: X-Kaltura-Proxy
context: http, server, location

Define o nome de um cabeçalho HTTP que é usado para prevenir loops de proxy de fallback (modos local/mapeado apenas).

vod_proxy_header_value

syntax: vod_proxy_header_value name
default: dumpApiRequest
context: http, server, location

Define o valor de um cabeçalho HTTP que é usado para prevenir loops de proxy de fallback (modos local/mapeado apenas).

Diretrizes de configuração - desempenho

vod_metadata_cache

syntax: vod_metadata_cache zone_name zone_size [expiration]
default: off
context: http, server, location

Configura o tamanho e o nome do objeto de memória compartilhada do cache de metadados de vídeo. Para arquivos MP4, este cache mantém o átomo moov.

vod_mapping_cache

syntax: vod_mapping_cache zone_name zone_size [expiration]
default: off
context: http, server, location

Configura o tamanho e o nome do objeto de memória compartilhada do cache de mapeamento para vod (apenas modo mapeado).

vod_live_mapping_cache

syntax: vod_live_mapping_cache zone_name zone_size [expiration]
default: off
context: http, server, location

Configura o tamanho e o nome do objeto de memória compartilhada do cache de mapeamento para ao vivo (apenas modo mapeado).

vod_response_cache

syntax: vod_response_cache zone_name zone_size [expiration]
default: off
context: http, server, location

Configura o tamanho e o nome do objeto de memória compartilhada do cache de resposta. O cache de resposta mantém manifestos e outros conteúdos não de vídeo (como segmento de inicialização DASH, chave de criptografia HLS etc.). Segmentos de vídeo não são armazenados em cache.

vod_live_response_cache

syntax: vod_live_response_cache zone_name zone_size [expiration]
default: off
context: http, server, location

Configura o tamanho e o nome do objeto de memória compartilhada do cache de resposta para respostas ao vivo que mudam de tempo. Este cache mantém os seguintes tipos de respostas para ao vivo: DASH MPD, HLS index M3U8, HDS bootstrap, MSS manifest.

vod_initial_read_size

syntax: vod_initial_read_size size
default: 4K
context: http, server, location

Define o tamanho da operação de leitura inicial do arquivo MP4.

vod_max_metadata_size

syntax: vod_max_metadata_size size
default: 128MB
context: http, server, location

Define o tamanho máximo suportado de metadados de vídeo (para MP4 - tamanho do átomo moov)

vod_max_frames_size

syntax: vod_max_frames_size size
default: 16MB
context: http, server, location

Define o limite no tamanho total dos quadros de um único segmento

vod_max_frame_count

syntax: vod_max_frame_count count
default: 1048576
context: http, server, location

Define o limite na contagem total dos quadros lidos para atender a requisições não de segmento (e.g. playlist).

vod_segment_max_frame_count

syntax: vod_segment_max_frame_count count
default: 65536
context: http, server, location

Define o limite na contagem total dos quadros lidos para atender a requisições de segmento.

vod_cache_buffer_size

syntax: vod_cache_buffer_size size
default: 256K
context: http, server, location

Define o tamanho dos buffers de cache usados ao ler quadros MP4.

vod_open_file_thread_pool

syntax: vod_open_file_thread_pool pool_name
default: off
context: http, server, location

Habilita o uso de abertura assíncrona de arquivos via pool de threads. O pool de threads deve ser definido com uma diretiva thread_pool, se nenhum nome de pool for especificado, o pool padrão é usado. Esta diretiva é suportada apenas no nginx 1.7.11 ou mais recente ao compilar com --add-threads. Nota: esta diretiva atualmente desabilita o uso do cache de arquivos abertos do nginx pelo módulo nginx-vod-module

vod_output_buffer_pool

syntax: vod_output_buffer_pool size count
default: off
context: http, server, location

Pré-aloca buffers para gerar dados de resposta, economizando a necessidade de alocar/liberar os buffers em cada requisição.

vod_performance_counters

syntax: vod_performance_counters zone_name
default: off
context: http, server, location

Configura o nome do objeto de memória compartilhada dos contadores de desempenho

Diretrizes de configuração - estrutura de URL

vod_base_url

syntax: vod_base_url url
default: veja abaixo
context: http, server, location

Define a URL base (esquema + domínio) que deve ser retornada nas respostas de manifesto. O valor do parâmetro pode conter variáveis, se o parâmetro avaliar para uma string vazia, URLs relativas serão usadas. Se o parâmetro avaliar para uma string que termina com /, presume-se que seja uma URL completa - o módulo apenas anexa o nome do arquivo a ela, em vez de uma URI completa. Se não definido, a URL base é determinada da seguinte forma: 1. Se a requisição não contiver um cabeçalho host (HTTP/1.0) URLs relativas serão retornadas 2. Caso contrário, a URL base será $scheme://$http_host A configuração atualmente afeta apenas HLS e DASH. Em MSS e HDS, URLs relativas são sempre retornadas.

vod_segments_base_url

syntax: vod_segments_base_url url
default: veja abaixo
context: http, server, location

Define a URL base (esquema + domínio) que deve ser usada para entregar segmentos de vídeo. O valor do parâmetro pode conter variáveis, se o parâmetro avaliar para uma string vazia, URLs relativas serão usadas. Se não definido, vod_base_url será usado. A configuração atualmente afeta apenas HLS.

vod_multi_uri_suffix

syntax: vod_multi_uri_suffix suffix
default: .urlset
context: http, server, location

Um sufixo de URL que é usado para identificar multi URLs. Uma multi URL é uma maneira de codificar várias URLs diferentes que devem ser reproduzidas juntas como um conjunto de streaming adaptativo, sob uma única URL. Quando o sufixo padrão é usado, uma URL de conjunto HLS pode parecer: http://host/hls/common-prefix,bitrate1,bitrate2,common-suffix.urlset/master.m3u8

vod_clip_to_param_name

syntax: vod_clip_to_param_name name
default: clipTo
context: http, server, location

O nome do parâmetro de requisição clip to.

vod_clip_from_param_name

syntax: vod_clip_from_param_name name
default: clipFrom
context: http, server, location

O nome do parâmetro de requisição clip from.

vod_tracks_param_name

syntax: vod_tracks_param_name name
default: tracks
context: http, server, location

O nome do parâmetro de requisição de trilhas.

vod_time_shift_param_name

syntax: vod_time_shift_param_name name
default: shift
context: http, server, location

O nome do parâmetro de requisição de deslocamento.

vod_speed_param_name

syntax: vod_speed_param_name name
default: speed
context: http, server, location

O nome do parâmetro de requisição de velocidade.

vod_lang_param_name

syntax: vod_lang_param_name name
default: lang
context: http, server, location

O nome do parâmetro de requisição de idioma.

vod_force_sequence_index

syntax: vod_force_sequence_index on/off
default: off
context: http, server, location

Usa o índice da sequência nas URIs de segmento, mesmo se houver apenas uma sequência

Diretrizes de configuração - cabeçalhos de resposta

vod_expires

syntax: vod_expires time
default: none
context: http, server, location

Define o valor dos cabeçalhos de resposta "Expires" e "Cache-Control" para requisições bem-sucedidas. Esta diretiva é semelhante à diretiva expires incorporada do nginx, exceto que suporta apenas o cenário de intervalo de expiração (epoch, max, off, tempo do dia não são suportados) A principal motivação para usar esta diretiva em vez da expires incorporada é ter uma expiração diferente para conteúdo VOD e dinâmico ao vivo. Se esta diretiva não for especificada, o nginx-vod-module não definirá os cabeçalhos "Expires" / "Cache-Control". Esta configuração afeta todos os tipos de requisições em playlists VOD e requisições de segmento em playlists ao vivo.

vod_expires_live

syntax: vod_expires_live time
default: none
context: http, server, location

Mesma que vod_expires (acima) para requisições ao vivo que não são dependentes do tempo e não são segmentos (e.g. HLS - master.m3u8, HDS - manifest.f4m).

vod_expires_live_time_dependent

syntax: vod_expires_live_time_dependent time
default: none
context: http, server, location

Mesma que vod_expires (acima) para requisições ao vivo que são dependentes do tempo (HLS - index.m3u8, HDS - bootstrap.abst, MSS - manifest, DASH - manifest.mpd).

vod_last_modified

syntax: vod_last_modified time
default: none
context: http, server, location

Define o valor do cabeçalho Last-Modified retornado na resposta, por padrão o módulo não retorna um cabeçalho Last-Modified. A razão para ter este parâmetro aqui é para suportar If-Modified-Since / If-Unmodified-Since. Como o módulo ngx_http_not_modified_filter_module embutido do nginx é executado antes de qualquer outro módulo de filtro de cabeçalho, ele não verá nenhum cabeçalho definido por add_headers / more_set_headers. Isso faz com que o nginx sempre responda como se o conteúdo tivesse mudado (412 para If-Unmodified-Since / 200 para If-Modified-Since) Para requisições ao vivo que não são segmentos (e.g. live DASH MPD), Last-Modified é definido para o tempo atual do servidor.

vod_last_modified_types

syntax: vod_last_modified_types mime-type1 mime-type2 ...
default: none
context: http, server, location

Define os tipos MIME para os quais o cabeçalho Last-Modified deve ser definido. O valor especial "*" corresponde a qualquer tipo MIME.

Diretrizes de configuração - costura de anúncios (apenas modo mapeado)

vod_dynamic_mapping_cache

syntax: vod_dynamic_mapping_cache zone_name zone_size [expiration]
default: off
context: http, server, location

Configura o tamanho e o nome do objeto de memória compartilhada do cache que armazena o mapeamento de clips dinâmicos.

vod_dynamic_clip_map_uri

syntax: vod_dynamic_clip_map_uri uri
default: none
context: http, server, location

Define a uri que deve ser usada para mapear clips dinâmicos. O valor do parâmetro pode conter variáveis, especificamente, $vod_clip_id contém o id do clip que deve ser mapeado. A resposta esperada desta uri é um objeto clip de concatenação em JSON.

vod_source_clip_map_uri

syntax: vod_source_clip_map_uri uri
default: none
context: http, server, location

Define a uri que deve ser usada para mapear clips de origem definidos usando a propriedade clipIds de concat. O valor do parâmetro pode conter variáveis, especificamente, $vod_clip_id contém o id do clip que deve ser mapeado. A resposta esperada desta uri é um objeto clip de origem em JSON.

vod_redirect_segments_url

syntax: vod_redirect_segments_url url
default: none
context: http, server, location

Define uma URL para a qual requisições por segmentos devem ser redirecionadas. O valor do parâmetro pode conter variáveis, especificamente, $vod_dynamic_mapping contém uma representação serializada do mapeamento de clips dinâmicos.

vod_apply_dynamic_mapping

syntax: vod_apply_dynamic_mapping mapping
default: none
context: http, server, location

Mapeia clips dinâmicos para clips de concatenação usando a expressão dada, previamente gerada por $vod_dynamic_mapping. O valor do parâmetro pode conter variáveis.

vod_notification_uri

syntax: vod_notification_uri uri
default: none
context: http, server, location

Define a uri que deve ser usada para emitir notificações. O valor do parâmetro pode conter variáveis, especificamente, $vod_notification_id contém o id da notificação que está sendo acionada. A resposta desta uri é ignorada.

Diretrizes de configuração - DRM / criptografia

vod_secret_key

syntax: vod_secret_key string
default: empty
context: http, server, location

Define a semente que é usada para gerar a chave de criptografia TS e IVs de criptografia DASH/MSS. O valor do parâmetro pode conter variáveis, e geralmente terá a estrutura "secret-$vod_filepath". Veja a lista de variáveis do nginx adicionadas por este módulo abaixo.

vod_encryption_iv_seed

syntax: vod_encryption_iv_seed string
default: empty
context: http, server, location

Define a semente que é usada para gerar o IV de criptografia, atualmente se aplica apenas a HLS/fMP4 com criptografia AES-128. O valor do parâmetro pode conter variáveis.

vod_drm_enabled

syntax: vod_drm_enabled on/off
default: off
context: http, server, location

Quando habilitado, o módulo criptografa os segmentos de mídia