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 video al 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 `kvssink` plugin. Per ulteriori informazioni, consulta [Scarica e crea l'SDK per produttori Kinesis Video Streams C\$1\$1](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 C\$1\$1 Producer utilizza per impostazione predefinita la regione Stati Uniti occidentali (Oregon) (`us-west-2`). 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 lo 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 supporto di input, scegli una delle seguenti opzioni:
------
#### [ Sample GStreamer video ]
Questa GStreamer pipeline genera un flusso video di prova dal vivo 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 formato H.264 e i fotogrammi chiave vengono generati al massimo ogni 10 fotogrammi, con una durata del frammento (nota anche come dimensione del gruppo di immagini (GoP)) di 1 secondo. kvssink prende il flusso video con codifica H.264, 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 fermare la GStreamer pipeline, selezionate la finestra del terminale e premete **CTRL\$1C**.
La GStreamer pipeline video di esempio ha il seguente aspetto:
![\[Immagine del modello di test standard con data e ora sovrapposti.\]](http://docs.aws.amazon.com/it_it/kinesisvideostreams/latest/dg/images/sample-video.png)
------
#### [ USB web cam ]
Esegui il seguente comando per far GStreamer rilevare automaticamente la tua fotocamera 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 GStreamer pipeline, selezionate la finestra del terminale e premete CTRL\$1C.**
Anziché consentire il GStreamer rilevamento automatico, puoi utilizzarlo `v4l2src` con un identificatore di dispositivo specifico. Esegui il comando seguente:
```
gst-device-monitor-1.0
```
Nell'output, vedrai alcuni dispositivi e l'inizio di una GStreamer pipeline 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 fermare la GStreamer pipeline, selezionate la finestra del terminale e premete CTRL\$1C.**
------
#### [ Raspberry Pi camera module 1 ]
Se stai usando il modulo telecamera Pi 1 o il modulo telecamera Pi 2 con`bcm2835-v4l2`, usa quanto segue:
```
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 GStreamer pipeline, selezionate la finestra del terminale e premete **CTRL\$1C**.
------
#### [ 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 fermare la GStreamer pipeline, selezionate la finestra del terminale e premete CTRL\$1C.**
------
#### [ Sample RTSP camera ]
Per questo esempio, utilizziamo l'hosting locale di un Gst-Rtsp-Server feed di telecamere RTSP dimostrativo. Quindi costruiamo una GStreamer pipeline per caricare il feed della telecamera RTSP nel flusso video Kinesis specificato.
**Per la configurazione sul tuo Raspberry Pi Gst-Rtsp-Server**
1. Installa le librerie di dipendenze necessarie per creare il Gst-Rtsp-Server progetto. Assicurati di avere 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 cartella degli esempi in. 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: il caricamento per la prima volta GStreamer potrebbe richiedere del tempo.
```
./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 il flusso 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 consiste nell'utilizzare l'utilità gst-discoverer-1.0. Type:
```
gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test"
```
L'output previsto è simile al 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 a Kinesis Video Stream utilizzando kvssink**
Questa GStreamer pipeline serve `rtspsrc` per connettersi al server RTSP per recuperare il flusso video RTP. Passa i frame a`rtph264depay`, che estrae i frame video con codifica H.264 dai pacchetti RTP. `h264parse`raggruppa i fotogrammi video nel formato che può comprendere. `kvssink` `kvssink`prende il flusso video con codifica H.264, 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 GStreamer pipeline, selezionate la finestra del terminale e premete CTRL\$1C.**
------
## Utilizza l'hardware
Alcuni modelli Raspberry Pi sono dotati di encoder H.264 con accelerazione hardware. È possibile utilizzarli al posto di, che è un codificatore software`x264enc`.
1. Assicurati che i GStreamer plugin 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 che si verificano di frequente e come risolverli.
### Nessun elemento del genere «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 Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md).
+ `libcamerasrc`: Vedi [Errore «Attivazione del pool di buffer non riuscita»](#rpi-troubleshoot-buffer) per installare l'`libcamerasrc` GStreamer elemento.
+ `omxh264enc`oppure`v4l2h264enc`:
Segui [Installa i prerequisiti del software](producersdk-cpp-rpi-software.md) per installare tutte le GStreamer librerie. Se le hai installate tutte e questi elementi non vengono visualizzati, significa che il tuo Raspberry Pi non ha l'hardware. Utilizzate invece l'encoder `x264enc` software.
+ Altro: segui questa procedura [Installa i prerequisiti del software](producersdk-cpp-rpi-software.md) per installare tutte le GStreamer librerie. Nei vari gruppi di GStreamer plugin si trovano diversi GStreamer elementi (buoni, cattivi, brutti), quindi assicurati di installarli tutti.
### Errore «Attivazione del pool di buffer non riuscita»
Se ricevi un errore come il seguente, significa che la pipeline utilizzata è in uso`v4l2src`, ma dovrebbe invece `libcamerasrc` utilizzarlo.
```
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 si utilizza la seguente pipeline con il modulo telecamera 2 senza `libcamerasrc` installato, è possibile che si verifichi questo errore quando GStreamer si tenta di rilevare automaticamente gli elementi da utilizzare.
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
**Risoluzione:**
Assicuratevi che `libcamerasrc` sia installato e utilizzatelo come elemento sorgente, anziché. `v4l2src` Digitate quanto segue per installare l'`libcamerasrc` GStreamer elemento:
```
sudo apt-get update
sudo apt-get install gstreamer1.0-libcamera
```
Una volta `libcamerasrc` installato, se si utilizza l'`autovideosrc`elemento, GStreamer dovrebbe passare automaticamente all'utilizzo della fonte corretta `libcamerasrc` anziché`v4l2src`.
### Errore del bus
Se ricevi un errore Bus poco dopo l'avvio `kvssink` (in genere, all'incirca nel momento in cui `PutMedia` viene completata la chiamata HTTP), significa che il tuo 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 l'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 allineata, è necessario impostare esplicitamente il `ALIGNED_MEMORY_MODEL` CMake flag su `ON` durante la compilazione, poiché l'impostazione predefinita è. `kvssink` `OFF` Per istruzioni più dettagliate, consulta la sezione. [Scarica e crea l'SDK per produttori Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md)
### Il timestamp si blocca e la pipeline si blocca
Quando si utilizza `x264enc` in una GStreamer pipeline, è possibile che si verifichino situazioni in cui la sequenza temporale 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, causando il blocco degli elementi a monte e lo stallo della pipeline.
Per ulteriori informazioni, consulta la [documentazione relativa ad GStreamer ](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c).
**Risoluzione:**
Configura `x264enc` con l'opzione di ottimizzazione. `zerolatency` 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 sia bassa latenza che alta qualità, prendete in considerazione approcci alternativi, come l'utilizzo di ottimizzazioni hardware o la ricerca di una webcam che emetta direttamente in formato H.264, saltando questa fase di codifica.
Per ulteriori informazioni, consulta [Utilizza l'hardware](#producersdk-cpp-rpi-utilize).
### Non è possibile eseguire più pipeline dallo stesso dispositivo contemporaneamente `v4l2`
`/dev/video0`È possibile accedere a dispositivi come questi da un solo 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, consulta Stack Exchange.](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897)
### Errore interno del flusso di dati
Quando si crea una GStreamer tubazione, si connettono gli elementi collegando il pad sorgente di un elemento al lavandino 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 registro indica che si è GStreamer verificato un problema durante il tentativo di stabilire una connessione (collegamento) tra i pad di due elementi della 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](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c), and/or modificare gli elementi utilizzati dalla pipeline.
I casi più comuni richiedono un `framerate` o `resolution` che la fotocamera non supporta. `gst-device-monitor-1.0`Utilizzatelo nel terminale per ottenere il supporto `framerates``resolutions`, e`formats`. È possibile utilizzare l' GStreamer elemento [videoscale](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) per regolare la risoluzione video e [videorate](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c) per regolare la frequenza dei fotogrammi video.
Per controllare i formati supportati per un singolo GStreamer elemento, digita nel terminale. `gst-inspect-1.0 element-name`