> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dwe.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# dweOS para GStreamer

> Este guia ajuda você a configurar a transmissão do dweOS com GStreamer.

<Warning>
  O dweOS não suporta oficialmente a transmissão com GStreamer. As etapas a seguir são apenas para Linux e Windows.

  OBSERVAÇÃO: a qualidade da transmissão pode ser prejudicada como resultado.
</Warning>

<Danger>
  O GStreamer pode ser muito complexo/elaborado, mesmo para configurar um único fluxo de vídeo. Muitos dos recursos de conveniência, como múltiplos fluxos e gravações ao vivo, são muito mais simples e vêm com uma interface de usuário no [Discovery](https://dwe.ai/products/discovery)
</Danger>

<Steps>
  <Step title="Verifique o dweOS">
    Após seguir a configuração do dweOS, prossiga para as próximas etapas.

    <Note>
      Anote a(s) porta(s) para as quais está sendo feita a transmissão.
    </Note>
  </Step>

  <Step title="Instale o GStreamer">
    <Tabs>
      <Tab title="Para Linux">
        No terminal, execute:

        ```sh theme={null}
        sudo apt update
        ```

        Em seguida, execute o seguinte para instalar o GStreamer:

        ```sh theme={null}
        sudo apt install gstreamer1.0-plugins-base gstreamer1.0-plugins-good gstreamer1.0-plugins-ugly gstreamer1.0-libav gstreamer1.0-tools                
        ```
      </Tab>

      <Tab title="Para Windows">
        <Steps>
          <Step title="Instalar o GStreamer">
            <Card title="Baixar o framework GStreamer" icon="stream" href="https://gstreamer.freedesktop.org/download/#windows">
              Clique aqui para baixar o GStreamer para desktop no seu laptop/PC.

              <Note>
                Certifique-se de baixar a versão MinGW e instalar tanto o runtime quanto o development.
              </Note>
            </Card>

            <Tip>
              Na dúvida, instale a versão de 64 bits, pois é a mais comum.
            </Tip>

            <Warning>
              O GStreamer seria instalado automaticamente na unidade D se você tiver mais de uma unidade no seu PC. Você pode alterar para a unidade C ao fazer uma instalação personalizada.

              Se você instalá-lo na unidade D, apenas tenha isso em mente ao configurar as variáveis de ambiente abaixo.
            </Warning>
          </Step>

          <Step title="Configurar variáveis de ambiente">
            <Steps>
              <Step>
                Para acessar as variáveis de ambiente, pressione `Win + R`
              </Step>

              <Step>
                Digite:

                ```
                SystemPropertiesAdvanced
                ```

                e pressione `Enter`
              </Step>

              <Step>
                Clique em `Variáveis de Ambiente...`

                <img src="https://mintcdn.com/deepwaterexplorationinc/NrWVR9Qe6FWmBE6d/dwe-os/legacy/images/system-properties-dialog.png?fit=max&auto=format&n=NrWVR9Qe6FWmBE6d&q=85&s=e43b7911ce525ec2b854c971afa1266b" width="80%" alt="Diálogo de Propriedades do Sistema" data-path="dwe-os/legacy/images/system-properties-dialog.png" />
              </Step>

              <Step>
                Destaque a variável `Path` em `Variáveis de usuário` clicando nela e depois clique em `Editar…` sob a caixa `Variáveis de usuário`.

                <img src="https://mintcdn.com/deepwaterexplorationinc/NrWVR9Qe6FWmBE6d/dwe-os/legacy/images/environment-variables-dialog.png?s=2d7ac09a6778fd1ceafd7a177335a9eb" width="80%" alt="Diálogo de Variáveis de Ambiente" data-path="dwe-os/legacy/images/environment-variables-dialog.png" />
              </Step>

              <Step>
                Uma nova janela deve aparecer e você deve clicar em `Novo` e adicionar um caminho para a pasta bin à lista. Neste caso, é:

                ```
                C:\gstreamer\1.0\mingw_x86_64\bin
                ```

                O caminho para o seu bin pode variar e pode ser encontrado onde você instalou o GStreamer nas etapas anteriores.

                <img src="https://mintcdn.com/deepwaterexplorationinc/NrWVR9Qe6FWmBE6d/dwe-os/legacy/images/environment-variables-dialog-2.png?fit=max&auto=format&n=NrWVR9Qe6FWmBE6d&q=85&s=84f2d6d273839b4a87e6f3346a66014b" width="80%" alt="Segundo Diálogo de Variáveis de Ambiente" data-path="dwe-os/legacy/images/environment-variables-dialog-2.png" />
              </Step>

              <Step>
                Depois disso, clique em `OK` em ambas as janelas e você deve estar pronto para prosseguir!
              </Step>
            </Steps>
          </Step>

          <Step title="Sucesso!">
            Você agora deve ter o GStreamer configurado e pronto para as próximas etapas!
          </Step>
        </Steps>
      </Tab>
    </Tabs>

    <Tip>
      Para verificar a configuração do GStreamer, abra o `CMD` e execute o seguinte:

      ```sh theme={null}
      gst-launch-1.0 --version
      ```

      Isso deve resultar em uma saída como:

      ```sh theme={null}
      gst-launch-1.0 version 1.16.2
      GStreamer 1.16.2
      https://launchpad.net/distros/ubuntu/+source/gstreamer1.0
      ```
    </Tip>
  </Step>

  <Step title="Identifique as variáveis para a linha de comando do GStreamer">
    Para conectar os fluxos de vídeo dos dispositivos conectados, primeiro você configurará o dweOS.

    <Steps>
      <Step>
        Primeiro identifique o endereço IP do seu laptop/desktop, que preencheremos no software dweOS.

        Isso pode ser feito executando o seguinte:

        ```sh theme={null}
        ip addr
        ```

        Você verá vários endereços; procure entre eles, especificamente os endereços após o texto:
        `inet`.
        <Tip>Provavelmente estará no formato `192.168.x.xx`</Tip>
      </Step>

      <Step>
        Você deverá substituir o IP coletado no dweOS em IP address e anotar a porta para a qual está transmitindo. (Padrão 5600)

        <Tip>
          Lembre-se de criar o endpoint de streaming com o botão `(+)` após preencher os campos!
        </Tip>

        Neste exemplo o IP coletado é 192.168.5.55, e a porta é 5600

        <img src="https://mintcdn.com/deepwaterexplorationinc/NrWVR9Qe6FWmBE6d/dwe-os/legacy/images/dwe-os-endpoints.png?fit=max&auto=format&n=NrWVR9Qe6FWmBE6d&q=85&s=eb7d2af6898b5fc125bae20ac92889e0" width="80%" alt="Endpoints dweOS" data-path="dwe-os/legacy/images/dwe-os-endpoints.png" />

        <Note>
          O campo Port sendo definido como 5601 é automático com o programa; os únicos endpoints em transmissão têm o ícone da câmera ao lado e um botão de lixeira para excluí-los.
        </Note>
      </Step>

      <Step>
        O formato do GStreamer é o seguinte:

        ```sh theme={null}
        gst-launch-1.0 [FLAGS] [SOURCE] ! [FILTER] ! [SINK]
        ```

        <Callout icon="key" color="#FFC107" iconType="regular">
          Com a porta em mente, existem alguns parâmetros do comando GStreamer para se ter atenção.

          **Flags essenciais**:

          * `-v` (Verbose): imprime informações do fluxo para que você possa ver qual resolução/formato está sendo negociado entre os elementos.
          * `-e` (EOS - End of Stream): crucial para gravação. Se você pressionar Ctrl+C sem essa flag, seu arquivo pode ficar corrompido (cabeçalhos ausentes). Essa flag força um encerramento limpo.
          * `--help-all`: lista todos os elementos disponíveis no seu sistema.

          **Sources (entrada)**:

          * `videotestsrc`: gera um padrão de teste (barras de cores, estática, etc.).

          * *Param*: `pattern=smpte` (ou `snow`, `ball`, etc.)

          * `autovideosrc` / `v4l2src`: sua webcam (Linux).

          * *Param*: `device=/dev/video0`

          * `filesrc`: lê um arquivo local.

          * *Param*: `location=./video.mp4`

          * `udpsrc`: recebe dados pela rede via UDP.
            * *Param*: `port=5600` (a porta para escutar).
            * *Param*: `caps="..."` (essencial! Informa ao GStreamer o que são os bytes brutos).
            * *Param*: `buffer-size=524288` (aumenta o buffer para evitar perda de pacotes em fluxos de alta resolução).
              * Tamanhos de buffer padrão para H264 é `96` e MJPEG é `26`

          **Sinks (saída)**

          * `autovideosink`: abre uma janela e reproduz o vídeo.

          * `fakesink`: descarta dados (útil para testar se um pipeline é executado sem erros).

          * `filesink`: grava em um arquivo.

          * *Param*: `location=output.mp4`

          * `udpsink`: transmite pela rede.

          **Essenciais (Filtros/Conversores)**

          * `videoconvert`: converte espaços de cores (por exemplo, de YUV para RGB). Se receber um erro "could not link", coloque isso no meio.

          * `videoscale`: redimensiona o vídeo.

          * `capsfilter`: força um formato específico. Sintaxe: `video/x-raw,width=1920,height=1080`.

          * `rtp[format]depay`: Depayloader. Desembrulha os pacotes RTP da rede para revelar o fluxo dentro deles.
            * *Exemplos*: `rtpjpegdepay` (para MJPEG), `rtph264depay` (para H.264).

          * `[format]dec`: Decodificador. Descomprime o vídeo em pixels brutos para exibição.
            * *Exemplos*: `jpegdec`, `avdec_h264`.
        </Callout>
      </Step>

      <Step>
        Aqui estão algumas linhas de exemplo para testar seu GStreamer:

        **Padrão de teste**

        ```sh theme={null}
        gst-launch-1.0 -v videotestsrc ! videoconvert ! autovideosink
        ```

        **Exibição de webcam (se disponível)**

        ```sh theme={null}
        gst-launch-1.0 -v v4l2src ! videoconvert ! autovideosink
        ```

        **Forçar webcam para 720p 30fps**

        ```sh theme={null}
        gst-launch-1.0 -v v4l2src ! image/jpeg,width=1280,height=720,framerate=30/1 ! jpegdec ! videoconvert ! autovideosink
        ```

        <Note>
          Para resoluções mais altas, a saída de vídeo geralmente é MJPEG comprimido.

          `image/jpeg` aceita o formato comprimido da câmera.

          `jpegdec` adiciona um decodificador para transformar esse fluxo JPEG de volta em vídeo bruto para que a janela possa exibi-lo.
        </Note>

        **Gravar webcam**

        ```sh theme={null}
        gst-launch-1.0 -e v4l2src ! videoconvert ! x264enc ! mp4mux ! filesink location=test.mp4
        ```

        <Note>
          Isso gravará em segundo plano; para finalizar o clipe, pressione `Ctrl + C`, e ele estará no diretório atual.

          Neste caso o arquivo se chama `test.mp4`, o qual podemos verificar com `ls -lh test.mp4`
        </Note>
      </Step>
    </Steps>
  </Step>

  <Step title="Configurando o streaming a partir do dweOS">
    Com um entendimento dos comandos do GStreamer, podemos começar a configurar o fluxo de vídeo especificamente com o dweOS.

    <Warning>
      Lembre-se de definir seu próprio IP como IP no endpoint de streaming!
    </Warning>

    Dependendo do codec de vídeo (MJPEG / H264) especificado no dweOS, execute um dos seguintes comandos:

    **MJPEG**

    ```sh theme={null}
    gst-launch-1.0 udpsrc port=5600 caps="application/x-rtp, encoding-name=JPEG, payload=26" ! rtpjpegdepay ! jpegdec ! autovideosink
    ```

    **H264**

    ```sh theme={null}
    gst-launch-1.0 udpsrc port=5600 caps="application/x-rtp, encoding-name=H264, payload=96" ! rtph264depay ! avdec_h264 ! autovideosink
    ```

    <Warning>
      Lembre-se de substituir o número da porta na linha de comando pela porta para a qual está sendo feita a transmissão!
    </Warning>

    Você agora deve ter uma transmissão ao vivo da sua câmera em uma janela!
  </Step>

  <Step title="Configurando a gravação">
    Para gravar um fluxo, mais uma vez o codec de vídeo importa!

    Você saberá que um fluxo está sendo gravado quando seu terminal contiver texto semelhante a este:

    <img src="https://mintcdn.com/deepwaterexplorationinc/NrWVR9Qe6FWmBE6d/dwe-os/legacy/images/gstreamer-recording.png?fit=max&auto=format&n=NrWVR9Qe6FWmBE6d&q=85&s=dc17f9d3c1c2346810c18865c8b8d007" width="80%" alt="Gravação com GStreamer" data-path="dwe-os/legacy/images/gstreamer-recording.png" />

    **MJPEG**

    Para MKV

    ```sh theme={null}
    gst-launch-1.0 -e udpsrc port=5600 caps="application/x-rtp, encoding-name=JPEG, payload=26" ! rtpjpegdepay ! jpegparse ! matroskamux ! filesink location=output_mjpeg.mkv
    ```

    <Note>
      A linha acima é para o formato MKV, pois AVI é incrivelmente sensível com GStreamer e requer que os dados de saída sejam formatados de forma muito específica. Embora possível, MJPEG para AVI é muito mais simples no [Discovery](https://dwe.ai/products/discovery), pois é a saída padrão.
    </Note>

    **H264**

    Para MKV

    ```sh theme={null}
    gst-launch-1.0 -e udpsrc port=5600 caps="application/x-rtp, encoding-name=H264, payload=96" ! rtph264depay ! h264parse ! matroskamux ! filesink location=output_h264.mkv
    ```

    Para MP4

    ```sh theme={null}
    gst-launch-1.0 -e udpsrc port=5600 caps="application/x-rtp, encoding-name=H264, payload=96" ! rtph264depay ! h264parse ! video/x-h264,stream-format=avc ! mp4mux ! filesink location=video.mp4
    ```
  </Step>

  <Step title="Sucesso!">
    Maravilhoso! Você agora deve ter as bases para configurar uma transmissão e gravação com GStreamer!
  </Step>
</Steps>

<Warning>
  Aviso:

  Com o GStreamer, configurar uma única câmera já exige bastante trabalho,
  e gravar vários fluxos de uma vez também exigiria bastante trabalho
  e desenvolvimento.

  Recomendamos o [Discovery](https://dwe.ai/products/discovery) caso suas configurações de câmera se tornem complexas.
</Warning>

<Card title="Baixar o Discovery" icon="video" href="https://dwe.ai/products/discovery">
  A solução multimídia tudo-em-um para fluxos de vídeo de rede submarina.
</Card>