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

> Diese Anleitung hilft Ihnen dabei, das Streaming von dweOS mit GStreamer einzurichten.

<Warning>
  dweOS unterstützt das Streaming mit GStreamer nicht offiziell. Die folgenden Schritte gelten nur für Linux und Windows.

  HINWEIS: Die Streamqualität kann darunter leiden.
</Warning>

<Danger>
  GStreamer kann sehr komplex/aufwendig sein, selbst um einen einzelnen Videostream einzurichten. Viele Komfortfunktionen wie mehrere Streams und Live-Aufnahmen sind in [Discovery](https://dwe.ai/products/discovery) viel einfacher und werden mit einer Benutzeroberfläche geliefert.
</Danger>

<Steps>
  <Step title="dweOS prüfen">
    Nachdem Sie die dweOS-Einrichtung durchgeführt haben, fahren Sie mit den nächsten Schritten fort.

    <Note>
      Notieren Sie sich den bzw. die Ports, an die gestreamt wird.
    </Note>
  </Step>

  <Step title="GStreamer installieren">
    <Tabs>
      <Tab title="Für Linux">
        Führen Sie im Terminal aus:

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

        Führen Sie dann Folgendes aus, um GStreamer zu installieren:

        ```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="Für Windows">
        <Steps>
          <Step title="GStreamer installieren">
            <Card title="GStreamer-Framework herunterladen" icon="stream" href="https://gstreamer.freedesktop.org/download/#windows">
              Klicken Sie hier, um GStreamer für Desktop auf Ihrem Laptop/PC herunterzuladen.

              <Note>
                Achten Sie darauf, die MinGW-Version herunterzuladen, und installieren Sie sowohl Runtime als auch Development.
              </Note>
            </Card>

            <Tip>
              Installieren Sie im Zweifelsfall die 64-Bit-Version, da diese verbreiteter ist.
            </Tip>

            <Warning>
              GStreamer wird automatisch auf dem Laufwerk D installiert, falls Sie mehrere Laufwerke auf Ihrem PC haben. Sie können es bei einer benutzerdefinierten Installation auf das Laufwerk C ändern.

              Wenn Sie es auf dem Laufwerk D installieren, denken Sie beim Einrichten der Umgebungsvariablen unten daran.
            </Warning>
          </Step>

          <Step title="Umgebungsvariablen konfigurieren">
            <Steps>
              <Step>
                Um zu den Umgebungsvariablen zu gelangen, drücken Sie `Win + R`.
              </Step>

              <Step>
                Geben Sie ein:

                ```
                SystemPropertiesAdvanced
                ```

                und drücken Sie `Enter`.
              </Step>

              <Step>
                Klicken Sie auf `Umgebungsvariablen...`.

                <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="System Properties Dialog" data-path="dwe-os/legacy/images/system-properties-dialog.png" />
              </Step>

              <Step>
                Markieren Sie die Variable `Path` unter `Benutzervariablen`, indem Sie darauf klicken, und klicken Sie dann unter der Box `Benutzervariablen` auf `Bearbeiten…`.

                <img src="https://mintcdn.com/deepwaterexplorationinc/NrWVR9Qe6FWmBE6d/dwe-os/legacy/images/environment-variables-dialog.png?s=2d7ac09a6778fd1ceafd7a177335a9eb" width="80%" alt="Environment Variables Dialog" data-path="dwe-os/legacy/images/environment-variables-dialog.png" />
              </Step>

              <Step>
                Ein neues Fenster sollte erscheinen und Sie klicken auf `Neu` und fügen einen Pfad zu Ihrem bin-Ordner zur Liste hinzu. In diesem Fall lautet er:

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

                Der Pfad zu Ihrem bin kann variieren und kann von dort ermittelt werden, wo Sie GStreamer in den vorherigen Schritten installiert haben.

                <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="Second Environment Variables Dialog" data-path="dwe-os/legacy/images/environment-variables-dialog-2.png" />
              </Step>

              <Step>
                Klicken Sie danach in beiden Fenstern auf `OK` und Sie sollten startklar sein!
              </Step>
            </Steps>
          </Step>

          <Step title="Erfolgreich!">
            Sie sollten nun GStreamer eingerichtet und bereit für die nächsten Schritte haben!
          </Step>
        </Steps>
      </Tab>
    </Tabs>

    <Tip>
      Um die GStreamer-Einrichtung zu überprüfen, öffnen Sie `CMD` und führen Sie Folgendes aus:

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

      Dies sollte zu einer Ausgabe wie dieser führen:

      ```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="Variablen für die GStreamer-Kommandozeile ermitteln">
    Um die Videostreams verbundener Geräte zu verknüpfen, konfigurieren Sie zunächst dweOS.

    <Steps>
      <Step>
        Ermitteln Sie zunächst die IP-Adresse Ihres Laptops/Desktops, die wir in die dweOS-Software eintragen werden.

        Dies können Sie tun, indem Sie Folgendes ausführen:

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

        Es werden Ihnen viele Adressen angezeigt. Suchen Sie darin gezielt nach Adressen nach dem Text:
        `inet`.
        <Tip>Sie hat höchstwahrscheinlich das Format `192.168.x.xx`.</Tip>
      </Step>

      <Step>
        Ersetzen Sie in dweOS unter „IP address" die ermittelte IP und notieren Sie sich den Port, an den gestreamt wird (Standard: 5600).

        <Tip>
          Denken Sie daran, den Streaming-Endpunkt mit der Schaltfläche `(+)` zu erstellen, sobald die Felder ausgefüllt sind!
        </Tip>

        In diesem Beispiel ist die ermittelte IP 192.168.5.55 und der Port ist 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="dweOS Endpoints" data-path="dwe-os/legacy/images/dwe-os-endpoints.png" />

        <Note>
          Das Feld „Port" wird automatisch vom Programm auf 5601 gesetzt; die einzigen Endpunkte, an die tatsächlich gestreamt wird, haben das Kamerasymbol daneben und eine Papierkorb-Schaltfläche zum Löschen.
        </Note>
      </Step>

      <Step>
        Das Format von GStreamer sieht wie folgt aus:

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

        <Callout icon="key" color="#FFC107" iconType="regular">
          Mit Blick auf den Port gibt es einige Parameter für den GStreamer-Befehl, die man kennen sollte.

          **Wichtige Flags**:

          * `-v` (Verbose): Gibt Stream-Informationen aus, damit Sie sehen, welche Auflösung/Format zwischen den Elementen ausgehandelt wird.
          * `-e` (EOS – End of Stream): Entscheidend für Aufnahmen. Wenn Sie ohne dieses Flag Strg+C drücken, könnte Ihre Datei beschädigt sein (fehlende Header). Dieses Flag erzwingt ein sauberes Herunterfahren.
          * `--help-all`: Listet jedes auf Ihrem System verfügbare Element auf.

          **Quellen (Input)**:

          * `videotestsrc`: Erzeugt ein Testbild (Farbbalken, Rauschen usw.).

          * *Parameter*: `pattern=smpte` (oder `snow`, `ball` usw.)

          * `autovideosrc` / `v4l2src`: Ihre Webcam (Linux).

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

          * `filesrc`: Liest eine lokale Datei.

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

          * `udpsrc`: Empfängt Daten über das Netzwerk via UDP.
            * *Parameter*: `port=5600` (Der Port, auf dem gehorcht wird).
            * *Parameter*: `caps="..."` (Unerlässlich! Teilt GStreamer mit, worum es sich bei den Rohbytes tatsächlich handelt).
            * *Parameter*: `buffer-size=524288` (Erhöht den Puffer, um Paketverlust bei hochauflösenden Streams zu verhindern).
              * Standard-Puffergrößen sind für H264 `96` und für MJPEG `26`.

          **Senken (Output)**

          * `autovideosink`: Öffnet ein Fenster und spielt das Video ab.

          * `fakesink`: Verwirft Daten (nützlich, um zu testen, ob eine Pipeline ohne Fehler läuft).

          * `filesink`: Schreibt in eine Datei.

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

          * `udpsink`: Streamt über das Netzwerk.

          **Grundlagen (Filter/Konverter)**

          * `videoconvert`: Konvertiert Farbräume (z. B. von YUV zu RGB). Wenn Sie einen „could not link"-Fehler erhalten, fügen Sie dies in die Mitte ein.

          * `videoscale`: Skaliert das Video.

          * `capsfilter`: Erzwingt ein bestimmtes Format. Syntax: `video/x-raw,width=1920,height=1080`.

          * `rtp[format]depay`: Depayloader. Entpackt RTP-Netzwerkpakete, um den enthaltenen Stream freizulegen.
            * *Beispiele*: `rtpjpegdepay` (für MJPEG), `rtph264depay` (für H.264).

          * `[format]dec`: Decoder. Dekomprimiert Video in Rohpixel zur Anzeige.
            * *Beispiele*: `jpegdec`, `avdec_h264`.
        </Callout>
      </Step>

      <Step>
        Hier sind einige Beispielzeilen, um Ihr GStreamer zu testen:

        **Testbild**

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

        **Webcam-Anzeige (falls verfügbar)**

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

        **Webcam auf 720p 30fps erzwingen**

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

        <Note>
          Bei höheren Auflösungen ist die Videoausgabe in der Regel komprimiertes MJPEG.

          `image/jpeg` nimmt das komprimierte Format von der Kamera an.

          `jpegdec` fügt einen Decoder hinzu, um diesen JPEG-Stream wieder in Rohvideo umzuwandeln, sodass das Fenster ihn anzeigen kann.
        </Note>

        **Webcam aufnehmen**

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

        <Note>
          Dies zeichnet im Hintergrund auf. Um den Clip zu beenden, drücken Sie `Strg + C`, und die Datei liegt danach im aktuellen Verzeichnis.

          In diesem Fall heißt die Datei `test.mp4`, deren Existenz Sie mit `ls -lh test.mp4` überprüfen können.
        </Note>
      </Step>
    </Steps>
  </Step>

  <Step title="Streaming aus dweOS einrichten">
    Mit einem Verständnis der GStreamer-Befehle können wir mit der Einrichtung des Videostreams speziell für dweOS beginnen.

    <Warning>
      Denken Sie daran, Ihre eigene IP als IP im Streaming-Endpunkt festzulegen!
    </Warning>

    Je nach dem in dweOS angegebenen Video-Codec (MJPEG / H264) führen Sie eines der folgenden Kommandos aus:

    **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>
      Denken Sie daran, die Portnummer in der Kommandozeile durch den Port zu ersetzen, an den gestreamt wird!
    </Warning>

    Sie sollten nun einen Live-Stream Ihrer Kamera in einem Fenster sehen!
  </Step>

  <Step title="Aufnahme einrichten">
    Um einen Stream aufzunehmen, ist erneut der Video-Codec entscheidend!

    Sie erkennen, dass ein Stream aufgenommen wird, wenn Ihr Terminal einen Text ähnlich diesem enthält:

    <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="GStreamer Recording" data-path="dwe-os/legacy/images/gstreamer-recording.png" />

    **MJPEG**

    Für 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>
      Die obige Zeile ist für ein MKV-Format, da AVI mit GStreamer äußerst heikel ist und die Ausgabedaten sehr spezifisch formatiert sein müssen. Zwar möglich, aber MJPEG zu AVI ist in [Discovery](https://dwe.ai/products/discovery) viel einfacher, da es die Standardausgabe ist.
    </Note>

    **H264**

    Für 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
    ```

    Für 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="Erfolgreich!">
    Wunderbar! Sie sollten nun die Bausteine haben, um einen Stream und eine Aufnahme mit GStreamer einzurichten!
  </Step>
</Steps>

<Warning>
  Warnung:

  Mit GStreamer erfordert bereits eine einzige Kamera-Einrichtung einigen Aufwand,
  und das Aufzeichnen mehrerer Streams gleichzeitig erfordert ebenfalls
  erheblichen Aufwand und Entwicklungsaufwand.

  Wir empfehlen [Discovery](https://dwe.ai/products/discovery), sollten Ihre Kamerakonfigurationen komplex werden.
</Warning>

<Card title="Discovery herunterladen" icon="video" href="https://dwe.ai/products/discovery">
  Die All-in-One-Multimedia-Lösung für Unterwasser-Netzwerk-Videostreams.
</Card>