Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Trasmetti i video sul tuo stream video Kinesis
Per eseguire l'applicazione di esempio sono necessarie le seguenti informazioni:
+ Il nome del flusso creato nella sezione [Prerequisiti](producersdk-cpp-rpi-prerequisites.md).
+ Le credenziali dell'account (ID chiave di accesso e chiave di accesso segreta) create in [Crea un utente IAM con il permesso di scrivere su Kinesis Video Streams](producersdk-cpp-rpi-iam.md).
+ GStreamer è in grado di localizzare il plugin. `kvssink` Per ulteriori informazioni, consulta [Scarica e crea l'SDK per produttori C\+\+ di Kinesis Video Streams](producersdk-cpp-rpi-download.md).
1. Imposta le credenziali e la regione.
```
export AWS_ACCESS_KEY_ID={{YourAccessKey}}
export AWS_SECRET_ACCESS_KEY={{YourSecretKey}}
export AWS_DEFAULT_REGION={{us-west-2}}
```
Per altri metodi di autenticazione, vedere[`Fornisci le credenziali a kvssink`](examples-gstreamer-plugin-parameters.md#credentials-to-kvssink).
**Nota**
L'SDK per produttori di C\+\+ utilizza la regione Stati Uniti occidentali (Oregon) (`us-west-2`) per impostazione predefinita. Per utilizzare l'impostazione predefinita, Regione AWS crea il tuo streaming video Kinesis nella regione Stati Uniti occidentali (Oregon).
Per utilizzare una regione diversa per il tuo streaming video Kinesis, imposta la seguente variabile di ambiente sulla tua regione (ad esempio,): {{us-east-1}}
```
export AWS_DEFAULT_REGION={{us-east-1}}
```
1. A seconda del contenuto multimediale di input, scegliete una delle seguenti opzioni:
------
#### [ Sample GStreamer video ]
Questa pipeline GStreamer genera un flusso video di test live con uno schema di test standard che viene eseguito a 10 fotogrammi al secondo con una risoluzione di 640x480 pixel. Viene aggiunto un overlay che mostra l'ora e la data correnti del sistema. Il video viene quindi codificato in un H.264 formato e i fotogrammi chiave vengono generati al massimo ogni 10 fotogrammi, ottenendo una durata del frammento (nota anche come dimensione di un gruppo di immagini (GoP)) di 1 secondo. kvssink prende il flusso H.264-encoded video, lo impacchetta nel formato contenitore Matroska (MKV) e lo carica nel flusso video Kinesis.
Esegui il comando seguente:
```
gst-launch-1.0 -v videotestsrc is-live=true \
! video/x-raw,framerate=10/1,width=640,height=480 \
! clockoverlay time-format="%a %B %d, %Y %I:%M:%S %p" \
! x264enc bframes=0 key-int-max=10 \
! h264parse \
! kvssink stream-name="{{YourStreamName}}"
```
Per interrompere la pipeline GStreamer, seleziona la finestra del terminale e premi ** CTRL\+C**.
La pipeline video di esempio di GStreamer ha il seguente aspetto:
------
#### [ USB web cam ]
Esegui il seguente comando per fare in modo che GStreamer rilevi automaticamente la tua videocamera USB:
```
gst-launch-1.0 autovideosrc \
! videoconvert \
! video/x-raw,format=I420,width=640,height=480 \
! x264enc bframes=0 key-int-max=45 tune=zerolatency byte-stream=true speed-preset=ultrafast \
! h264parse \
! video/x-h264,stream-format=avc,alignment=au,profile=baseline \
! kvssink stream-name="{{YourStreamname}}"
```
Per interrompere la pipeline di GStreamer, seleziona la finestra del terminale e premi CTRL\+C. ** **
Invece di lasciare che GStreamer si rilevi automaticamente, puoi utilizzarlo con un identificatore specifico del dispositivo. `v4l2src` Esegui il comando seguente:
```
gst-device-monitor-1.0
```
Nell'output, vedrai alcuni dispositivi e l'avvio di una pipeline GStreamer su come utilizzare il dispositivo:
```
Device found:
name : H264 USB Camera: USB Camera
class : Video/Source
caps : video/x-h264, stream-format=(string)byte-stream, alignment=(string)au, width=(int)1920, height=(int)1080, pixel-aspect-ratio=(fraction)1/1, colorimetry=(string){ 2:4:7:1 }, framerate=(fraction){ 30/1, 25/1, 15/1 };
...
properties:
device.path = /dev/video4
udev-probed = false
device.api = v4l2
v4l2.device.driver = uvcvideo
v4l2.device.card = "H264\ USB\ Camera:\ USB\ Camera"
v4l2.device.bus_info = usb-3f980000.usb-1.3
v4l2.device.version = 265767 (0x00040e27)
v4l2.device.capabilities = 2216689665 (0x84200001)
v4l2.device.device_caps = 69206017 (0x04200001)
gst-launch-1.0 {{v4l2src device=/dev/video4}} ! ...
```
Per interrompere la pipeline GStreamer, seleziona la finestra del terminale e premi CTRL\+C. ** **
------
#### [ Raspberry Pi camera module 1 ]
Se stai usando il modulo telecamera Pi 1 o il modulo telecamera Pi 2 con, usa quanto segue: `bcm2835-v4l2`
```
gst-launch-1.0 v4l2src device=/dev/video0 \
! videoconvert \
! video/x-raw,format=I420,width=640,height=480 \
! x264enc bframes=0 key-int-max=45 bitrate=500 tune=zerolatency \
! h264parse ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \
! kvssink stream-name="{{YourStreamname}}"
```
Per interrompere la pipeline GStreamer, seleziona la finestra del terminale e premi CTRL\+C. ** **
------
#### [ Raspberry Pi camera module 2 or 3 ]
Se stai usando lo `libcamera` stack moderno, usa la seguente pipeline GStreamer:
```
gst-launch-1.0 libcamerasrc \
! video/x-raw,width=640,height=480,framerate=30/1,format=I420 \
! videoconvert \
! x264enc speed-preset=ultrafast tune=zerolatency byte-stream=true key-int-max=75 \
! video/x-h264,level='(string)4' \
! h264parse \
! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1 \
! kvssink stream-name="{{YourStreamname}}"
```
Per interrompere la pipeline GStreamer, seleziona la finestra del terminale e premi CTRL\+C. ** **
------
#### [ Sample RTSP camera ]
Per questo esempio, utilizziamo per ospitare localmente un feed dimostrativo Gst-Rtsp-Server di una telecamera RTSP. Quindi costruiamo una pipeline GStreamer per caricare il feed della telecamera RTSP nel flusso video Kinesis specificato.
**Per configurare sul tuo Raspberry Pi Gst-Rtsp-Server **
1. Installa le librerie di dipendenze necessarie per creare il Gst-Rtsp-Server progetto. Assicurati di aver installato anche i prerequisiti del software. Digita quanto segue nel tuo terminale:
```
sudo apt-get update
sudo apt-get install libgstrtspserver-1.0
```
1. Scarica la versione 1.22 di GStreamer sul tuo Raspberry Pi.
```
git clone https://gitlab.freedesktop.org/gstreamer/gstreamer.git --single-branch -b 1.22
```
1. Cambia le directory nella directory degli esempi nel gst-rtsp-server.
```
cd gstreamer
cd subprojects
cd gst-rtsp-server
cd examples
```
1. Compila test-launch.c in un eseguibile chiamato test-launch usando gcc.
```
gcc -o test-launch test-launch.c `pkg-config --cflags --libs gstreamer-rtsp-server-1.0`
```
1. Esegui l'eseguibile con i seguenti argomenti. Nota: GStreamer potrebbe richiedere del tempo per caricarsi per la prima volta.
```
./test-launch "videotestsrc is-live=true ! video/x-raw,height=480,width=640,framerate=10/1 ! videoconvert ! x264enc tune=zerolatency bitrate=512 key-int-max=25 bframes=0 ! h264parse ! rtph264pay ! name=pay0 pt=96"
```
Verrà visualizzato l’output seguente:
```
stream ready at rtsp://127.0.0.1:8554/test
```
1. Verifica lo streaming video RTSP. Puoi usare qualsiasi visualizzatore RTSP. Ad esempio, VLC media player. Per utilizzare VLC media player per visualizzare il tuo live streaming, apri un nuovo terminale e digita:
```
sudo apt-get install vlc
```
per installare VLC media player. Quindi digita:
```
vlc rtsp://127.0.0.1:8554/test
```
Dovrebbe apparire una finestra VLC con il live streaming. In caso contrario, controlla che l'eseguibile test-launch sia ancora in esecuzione e controlla l'output per eventuali errori.
Un altro modo per verificare il flusso RTSP è utilizzare l'utilità gst-discoverer-1.0. Type:
```
gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test"
```
L'output previsto è il seguente:
```
Analyzing rtsp://127.0.0.1:8554/test
Done discovering rtsp://127.0.0.1:8554/test
Properties:
Duration: 99:99:99.999999999
Seekable: no
Live: yes
unknown #0: application/x-rtp
video #1: H.264 (Constrained Baseline Profile)
Stream ID: 359314d7d4bba383223927d7e57d4244d0800e629c626be81c505055c62170e2/video:0:0:RTP:AVP:96
Width: 640
Height: 480
Depth: 24
Frame rate: 10/1
Pixel aspect ratio: 1/1
Interlaced: false
Bitrate: 0
Max bitrate: 0
```
**Per inviare il feed RTSP al tuo Kinesis Video Stream usando kvssink **
Questa pipeline GStreamer utilizza la connessione `rtspsrc` al server RTSP per recuperare il flusso video RTP. Passa i frame al`rtph264depay`, che estrae i frame video dai pacchetti RTP. H.264-encoded `h264parse`raggruppa i fotogrammi video nel formato `kvssink` comprensibile. `kvssink`prende il flusso H.264-encoded video, lo impacchetta nel formato contenitore Matroska (MKV) e lo carica nel flusso video Kinesis.
Esegui il comando seguente:
```
gst-launch-1.0 -v rtspsrc location="rtsp://127.0.0.1:8554/test" short-header=true \
! rtph264depay \
! h264parse \
! video/x-h264,format=avc,alignment=au \
! kvssink stream-name="{{YourStreamName}}"
```
Per interrompere la pipeline GStreamer, selezionate la finestra del terminale e premete CTRL\+C. ** **
------
## Utilizza l'hardware
Alcuni modelli Raspberry Pi sono dotati di encoder con accelerazione hardware H.264 . Puoi usarli al posto di, che è un codificatore `x264enc` software.
1. Assicurati che i plugin GStreamer siano installati:
```
sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-bad
```
1. Type:
```
gst-inspect-1.0 | grep h264
```
Determina se sono disponibili i seguenti elementi:
+ omxh264enc
+ v4l2h264enc
Se sono disponibili, puoi usarli. Ecco alcuni esempi di pipeline che utilizzano questi elementi:
**`omxh264enc`:**
```
gst-launch-1.0 v4l2src device=/dev/video0 \
! videoconvert \
! video/x-raw,format=I420,width=640,height=480 \
! {{omxh264enc}} control-rate=2 target-bitrate=512000 periodicity-idr=45 inline-header=FALSE \
! h264parse ! video/x-h264,stream-format=avc,alignment=au,profile=baseline \
! kvssink stream-name="{{raspberry}}"
```
**`v4l2h264enc`e`v4l2convert`: **
```
gst-launch-1.0 libcamerasrc \
! video/x-raw,width=640,height=480,framerate=30/1,format=I420 \
! {{v4l2convert}} \
! {{v4l2h264enc}} extra-controls="controls,repeat_sequence_header=1" \
! video/x-h264,level='(string)4' \
! h264parse \
! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1 \
! kvssink stream-name="{{test-stream}}"
```
## Problemi di runtime
Di seguito sono riportati alcuni problemi di runtime riscontrati di frequente e come risolverli.
### Nessun elemento di questo tipo «xxxxxxxxx»
Se ricevi un errore come il seguente, significa che ti manca un plugin GStreamer:
```
WARNING: erroneous pipeline: no element "videoconvert"
```
**Risoluzione:**
In base all'elemento mancante, stabilisci l'azione appropriata:
+ `kvssink`: Vedi[Scarica e crea l'SDK per produttori C\+\+ di Kinesis Video Streams](producersdk-cpp-rpi-download.md).
+ `libcamerasrc`: Vedi [Errore «Attivazione del buffer pool non riuscita»](#rpi-troubleshoot-buffer) per installare l'elemento `libcamerasrc` GStreamer.
+ `omxh264enc`oppure: `v4l2h264enc`
Segui [Prerequisiti per l'installazione del software](producersdk-cpp-rpi-software.md) per installare tutte le librerie GStreamer. Se le hai installate tutte e questi elementi non vengono visualizzati, significa che il tuo Raspberry Pi non ha l'hardware. Usa invece l'encoder `x264enc` software.
+ Altro: Segui [Prerequisiti per l'installazione del software](producersdk-cpp-rpi-software.md) per installare tutte le librerie GStreamer. Diversi elementi di GStreamer si trovano nei vari gruppi di plugin GStreamer (buoni, cattivi, brutti), quindi assicurati di installarli tutti.
### Errore «Attivazione del buffer pool non riuscita»
Se ricevi un errore come il seguente, significa che la pipeline utilizzata sta utilizzando`v4l2src`, ma dovrebbe invece `libcamerasrc` utilizzarla.
```
ERROR bufferpool gstbufferpool.c:572:gst_buffer_pool_set_active:source:pool0:src start failed
WARN v4l2src gstv4l2src.c:976:gst_v4l2src_decide_allocation: error: Failed to allocate required memory.
WARN v4l2src gstv4l2src.c:976:gst_v4l2src_decide_allocation: error: Buffer pool activation failed
WARN basesrc gstbasesrc.c:3352:gst_base_src_prepare_allocation: Subclass failed to decide allocation
Error received from element source: Failed to allocate required memory.
WARN basesrc gstbasesrc.c:3132:gst_base_src_loop: error: Internal data stream error.
Debugging information: ../sys/v4l2/gstv4l2src.c(976): gst_v4l2src_decide_allocation (): /GstPipeline:live-kinesis-pipeline/GstV4l2Src:source:
Buffer pool activation failed
WARN basesrc gstbasesrc.c:3132:gst_base_src_loop: error: streaming stopped, reason not-negotiated (-4)
```
Ad esempio, se state usando la seguente pipeline con il modulo telecamera 2 senza `libcamerasrc` installazione, potreste riscontrare questo errore quando GStreamer sta cercando di rilevare automaticamente quali elementi usare.
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
**Risoluzione:**
Assicurati che `libcamerasrc` sia installato e usalo come elemento sorgente, anziché. `v4l2src` Digita quanto segue per installare l'elemento `libcamerasrc` GStreamer:
```
sudo apt-get update
sudo apt-get install gstreamer1.0-libcamera
```
Una volta `libcamerasrc` installato, se stai usando l'`autovideosrc`elemento, GStreamer dovrebbe passare automaticamente all'uso della fonte corretta anziché. `libcamerasrc` `v4l2src`
### Errore del bus
Se ricevete un errore del bus poco dopo l'avvio `kvssink` (in genere, all'incirca nel momento in cui `PutMedia` viene completata la chiamata HTTP), significa che il vostro Raspberry Pi non supporta l'accesso non allineato alla memoria. I log avranno il seguente aspetto:
```
INFO Camera camera.cpp:1197 configuring streams: (0) 640x480-YUV420
INFO RPI pisp.cpp:1450 Sensor: /base/axi/pcie@120000/rp1/i2c@88000/imx708@1a - Selected sensor format: 1536x864-SBGGR10_1X10 - Selected CFE format: 1536x864-PC1B
[INFO ] kinesisVideoStreamFormatChanged(): Stream format changed.
[DEBUG] setRequestHeader(): Appending header to request: user-agent -> AWS-SDK-KVS-CPP-CLIENT/3.4.2/1.5.3 GCC/12.2.0 Linux/6.6.51+rpt-rpi-v8 aarch64 CPPSDK
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-stream-name -> demo-stream
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-producer-start-timestamp -> 1732012345.678
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-fragment-acknowledgment-required -> 1
[DEBUG] setRequestHeader(): Appending header to request: x-amzn-fragment-timecode-type -> ABSOLUTE
[DEBUG] setRequestHeader(): Appending header to request: transfer-encoding -> chunked
[DEBUG] setRequestHeader(): Appending header to request: connection -> keep-alive
[INFO ] putStreamResultEvent(): Put stream result event. New upload handle 0
[WARN ] notifyDataAvailable(): [demo-stream] Failed to un-pause curl with error: 43. Curl object 0xe2f6f418
Bus error
```
Kinesis Video Streams PIC utilizza un accesso non allineato alla memoria per ottimizzare l'utilizzo della memoria, che non è supportato da tutti i dispositivi.
**Risoluzione:**
Per utilizzare l'SDK in modalità di accesso alla memoria allineato, è necessario impostare esplicitamente il flag `ALIGNED_MEMORY_MODEL` CMake su durante la compilazione, poiché per `ON` impostazione predefinita è. `kvssink` `OFF` Vedi per istruzioni più dettagliate. [Scarica e crea l'SDK per produttori C\+\+ di Kinesis Video Streams](producersdk-cpp-rpi-download.md)
### Il timestamp si blocca e la pipeline si blocca
Quando si utilizza `x264enc` in una pipeline GStreamer, è possibile che si verifichino situazioni in cui la timeline della pipeline rallenta in modo significativo o si blocca completamente nel giro di pochi secondi.
Ciò si verifica perché le impostazioni `x264enc` predefinite possono introdurre un'elevata latenza di codifica, che supera la capacità del buffer di input predefinito. Di conseguenza, il buffer di input si riempie, provocando il blocco degli elementi a monte e il blocco della pipeline.
Per ulteriori informazioni, consulta la documentazione di GStreamer. [https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c)
**Risoluzione:**
Configura `x264enc` con l'opzione di `zerolatency` ottimizzazione. Ciò riduce significativamente la latenza di codifica ottimizzando gli scenari in tempo reale, garantendo che i frame vengano elaborati e generati più rapidamente.
Configurazione di esempio:
```
... ! x264enc {{tune=zerolatency}} byte-stream=true speed-preset=ultrafast bframes=0 key-int-max=60 ! ...
```
**Nota**
Sebbene questa soluzione prevenga efficacemente lo stallo della pipeline, può influire sull'efficienza e sulla qualità della codifica. Per gli scenari che richiedono bassa latenza e alta qualità, prendi in considerazione approcci alternativi, come l'utilizzo di ottimizzazioni hardware o la ricerca di una web cam che emetta H.264 direttamente l'output, saltando questa fase di codifica.
Per ulteriori informazioni, consulta [Utilizza l'hardware](#producersdk-cpp-rpi-utilize).
### Non è possibile eseguire più pipeline dallo stesso dispositivo v4l2 contemporaneamente ``
A dispositivi come questo `/dev/video0` è possibile accedere solo da un processo alla volta. Se più processi tentano di accedervi contemporaneamente, il secondo attende il completamento del primo.
**Risoluzione:**
Crea un dispositivo di loopback, che consenta a più processi di utilizzare l'interfaccia di loopback contemporaneamente. Per ulteriori informazioni, vedere Stack Exchange. [https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897)
### Errore interno del flusso di dati
Quando crei una pipeline GStreamer, colleghi gli elementi collegando il pad sorgente di un elemento al sink pad di un altro elemento. Questo processo di collegamento consente il flusso di dati dall'elemento sorgente all'elemento sink, formando una pipeline di dati.
Il messaggio di errore «Pad link failed» nel log indica che GStreamer ha riscontrato un problema nel tentativo di stabilire una connessione (link) tra i pad di due elementi nella pipeline.
```
Pad link failed
Error received from element udpsrc0: Internal data stream error.
```
**Risoluzione:**
Determina quali elementi non riescono a collegarsi tra loro. Per restringere l'ambito della pipeline, rimuovete gli elementi dalla pipeline. Sostituite l'elemento più a destra con `fakesink` e rimuovete gli elementi uno alla volta.
Potrebbe essere necessario modificare gli elementi [ capsfilter, and/or modificare ](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c) gli elementi utilizzati dalla pipeline.
I casi più comuni sono richiedere un `framerate` o `resolution` che la fotocamera non supporta. Utilizzate `gst-device-monitor-1.0` nel terminale per ottenere i file supportati`framerates`,`resolutions`, e`formats`. È possibile utilizzare l'elemento [ Videoscale ](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) GStreamer per regolare la risoluzione video e [ videorate ](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c) per regolare la frequenza dei fotogrammi del video.
Per controllare i formati supportati per un singolo elemento GStreamer, digita nel terminale. `gst-inspect-1.0 element-name`