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à.
# Usa l'SDK C\$1\$1 Producer su Raspberry Pi
Raspberry Pi è un piccolo computer economico che può essere utilizzato per insegnare e apprendere competenze di programmazione di base. Questo tutorial descrive come configurare e utilizzare l'SDK per produttori Amazon Kinesis Video Streams C\$1\$1 su un dispositivo Raspberry Pi. I passaggi includono anche come verificare l'installazione utilizzando l'applicazione demo. GStreamer
**Topics**
+ [Prerequisiti](producersdk-cpp-rpi-prerequisites.md)
+ [Crea un utente IAM con il permesso di scrivere su Kinesis Video Streams](producersdk-cpp-rpi-iam.md)
+ [Collega il tuo Raspberry Pi alla tua rete Wi-Fi](producersdk-cpp-rpi-wifi.md)
+ [Connect da remoto al tuo Raspberry Pi](producersdk-cpp-rpi-connect.md)
+ [Configura la fotocamera Raspberry Pi](producersdk-cpp-rpi-camera.md)
+ [Installa i prerequisiti del software](producersdk-cpp-rpi-software.md)
+ [Scarica e crea l'SDK per produttori Kinesis Video Streams C\$1\$1](producersdk-cpp-rpi-download.md)
+ [Trasmetti video al tuo stream video Kinesis](producersdk-cpp-rpi-run.md)
+ [Riproduci contenuti multimediali dal tuo flusso video Kinesis](producersdk-cpp-rpi-playback.md)
+ [Risoluzione dei problemi di compilazione su C\$1\$1 Producer SDK per Raspberry Pi](troubleshoot-rpi.md)
# Prerequisiti
Prima di configurare l'SDK C\$1\$1 Producer sul tuo Raspberry Pi, assicurati di avere i seguenti prerequisiti:
+ Un dispositivo Raspberry Pi con la seguente configurazione:
+ Versione della scheda: 3 Model B o versioni successive.
+ Un [modulo fotocamera](https://www.raspberrypi.com/documentation/accessories/camera.html) collegato o una videocamera USB collegata (webcam).
+ Una scheda SD con una capacità minima di 8 GB.
+ Sistema operativo Raspbian (kernel 4.9 o versioni successive) installato. È possibile scaricare l'immagine più recente del sistema operativo Raspberry Pi (precedentemente chiamato Raspbian) dal sito Web di [Raspberry Pi](https://www.raspberrypi.com/software/). Segui le istruzioni di Raspberry Pi per [installare l'immagine scaricata su una scheda SD](https://www.raspberrypi.com/documentation/computers/getting-started.html#install-an-operating-system).
+ E Account AWS con un flusso video Kinesis. Per ulteriori informazioni, consulta [Nozioni di base su Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html).
# Crea un utente IAM con il permesso di scrivere su Kinesis Video Streams
Se non l'hai già fatto, configura un utente AWS Identity and Access Management (IAM) con le autorizzazioni per scrivere su un flusso video Kinesis.
Queste procedure hanno lo scopo di aiutarti a iniziare rapidamente a utilizzare una coppia di chiavi di AWS accesso. I dispositivi possono utilizzare certificati X.509 a cui connettersi. AWS IoT[Controllo dell'accesso alle risorse Kinesis Video Streams tramite AWS IoT](how-iot.md)Per ulteriori informazioni su come configurare il dispositivo per l'utilizzo dell'autenticazione basata su certificati, consulta.
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Nel menu di navigazione a sinistra, scegli **Users (Utenti)**.
1. Per creare un nuovo utente, scegli **Add user (Aggiungi utente)**.
1. Fornire un **User name (Nome utente)** descrittivo per l'utente, ad esempio **kinesis-video-raspberry-pi-producer**.
1. Sotto **Access type (Tipo di accesso)**, scegli **Programmatic access (Accesso programmatico)**.
1. Scegli **Successivo: autorizzazioni**.
1. In **Imposta le autorizzazioni per kinesis-video-raspberry-pi -producer**, scegli **Allega direttamente le politiche esistenti**.
1. Scegli **Crea policy**. La pagina **Create policy (Crea policy)** viene visualizzata in una nuova scheda del browser Web.
1. Scegli la scheda **JSON**.
1. Copia la seguente policy JSON e incollala nell'area del testo. Questa politica concede all'utente l'autorizzazione a creare e scrivere dati nei flussi video Kinesis.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:CreateStream",
"kinesisvideo:GetDataEndpoint",
"kinesisvideo:PutMedia"
],
"Resource": [
"*"
]
}]
}
```
------
1. Scegliere **Esamina policy**.
1. Fornire un **Name (Nome)** alla policy, ad esempio **kinesis-video-stream-write-policy**.
1. Scegli **Crea policy**.
1. Torna alla scheda **Add user (Aggiungi utente)** nel browser e scegli **Refresh (Aggiorna)**.
1. Nella casella di ricerca digita il nome della policy creata.
1. Seleziona la casella di controllo accanto alla nuova policy nell'elenco.
1. Scegliere **Next:Review (Successivo:Rivedi)**.
1. Selezionare **Create user (Crea utente)**.
1. Nella console viene visualizzato l'**ID chiave di accesso** per il nuovo utente. Scegli **Show (Mostra)** per visualizzare la **Secret Access Key (Chiave di accesso segreta)**. Registra questi valori perché saranno necessari per la configurazione dell'applicazione.
# Collega il tuo Raspberry Pi alla tua rete Wi-Fi
Se usi un monitor e una tastiera collegati, passa a [Configura la fotocamera Raspberry Pi](producersdk-cpp-rpi-camera.md).
Queste istruzioni sono state scritte per aiutarti a configurare il tuo Raspberry Pi quando viene eseguito in modalità *headless*, ovvero senza tastiera, monitor o cavo di rete collegati. Segui le istruzioni riportate di seguito per configurare il tuo Raspberry Pi in modo che tenti automaticamente di connettersi alla rete specificata, permettendo al computer host di accedervi tramite SSH.
1. Sul tuo computer, crea un file denominato `wpa_supplicant.conf`.
1. Copia il testo seguente e incollalo nel `wpa_supplicant.conf` file:
```
country=US
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
network={
ssid="Your Wi-Fi SSID"
scan_ssid=1
key_mgmt=WPA-PSK
psk="Your Wi-Fi Password"
}
```
Sostituisci i valori `ssid` e `psk` con le informazioni per la rete Wi-Fi.
1. Copia il file `wpa_supplicant.conf` nella scheda SD. Devi copiarlo nella directory principale del volume `boot`.
1. Inserisci la scheda SD nel Raspberry Pi e accendi il dispositivo. Il dispositivo viene aggiunto alla rete Wi-Fi e SSH viene abilitato.
# Connect da remoto al tuo Raspberry Pi
Se usi un monitor e una tastiera collegati, passa a [Configura la fotocamera Raspberry Pi](producersdk-cpp-rpi-camera.md).
Queste istruzioni sono state scritte per aiutarti a configurare il tuo Raspberry Pi quando viene eseguito in modalità *headless*, ovvero senza tastiera, monitor o cavo di rete collegati. Segui le istruzioni riportate di seguito per localizzare il tuo Raspberry Pi sulla rete e accedervi tramite SSH dal computer host.
1. Prima di connetterti al dispositivo Raspberry Pi in remoto, esegui una delle operazioni seguenti per determinarne l'indirizzo IP:
+ Se disponi dell'accesso al router Wi-Fi della rete, controlla i dispositivi Wi-Fi connessi. Trova il dispositivo denominato `Raspberry Pi` per trovare l'indirizzo IP del dispositivo.
+ Se non disponi dell'accesso al router Wi-Fi della rete, puoi usare altri prodotti software per trovare i dispositivi in rete. [Fing](https://www.fing.com/) è un'applicazione molto diffusa disponibile per dispositivi sia Android che iOS. Puoi utilizzare la versione gratuita di questa applicazione per trovare gli indirizzi IP dei dispositivi in rete.
1. Una volta trovato l'indirizzo IP del dispositivo Raspberry Pi, puoi usare qualsiasi applicazione terminale per connetterti.
+ Su macOS o Linux, usa `ssh`:
```
ssh pi@
```
+ Su Windows, usa [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), un client SSH gratuito per Windows.
Per una nuova installazione di Raspbian, il nome utente è **pi** e la password è **raspberry**. Ti consigliamo di [modificare la password predefinita](https://www.raspberrypi.com/documentation/computers/configuration.html#change-user-password-nonint).
# Configura la fotocamera Raspberry Pi
Segui questi passaggi per configurare il [modulo videocamera Raspberry Pi](https://www.raspberrypi.com/documentation/accessories/camera.html) per inviare video dal dispositivo a un flusso video Kinesis.
**Nota**
Se utilizzi una webcam USB, passa a. [Installa i prerequisiti del software](producersdk-cpp-rpi-software.md)
------
#### [ Camera module 1 ]
Segui queste istruzioni per aggiornare il file dei moduli, abilitare l'interfaccia della fotocamera e verificare la funzionalità della fotocamera. L'aggiornamento del file dei moduli indica al Raspberry Pi quali moduli del kernel caricare al momento dell'avvio. Il driver della fotocamera non viene caricato di default per risparmiare risorse di sistema sui dispositivi Raspberry Pi che non utilizzano una fotocamera.
1. Apri un editor per apportare modifiche al file dei moduli. Apri il terminale e usa il seguente comando per modificare il file usando l'`nano`editor:
```
sudo nano /etc/modules
```
1. Aggiungi la riga seguente alla fine del file, se non è già presente:
```
bcm2835-v4l2
```
1. Salvare il file e uscire dall'editor. Per salvare e uscire usando l'`nano`editor, usa Ctrl\$1X.
1. Riavvia il dispositivo Raspberry Pi:
```
sudo reboot
```
1. Quando il dispositivo si riavvia, esegui di nuovo la connessione utilizzando l'applicazione terminale se ti connetti in remoto.
1. Aprire `raspi-config`:
```
sudo raspi-config
```
1. **Scegli **Opzioni di interfaccia**, Legacy Camera.** **Nelle versioni precedenti del sistema operativo Raspbian, questa opzione di menu potrebbe trovarsi in Opzioni di **interfaccia, Fotocamera**.**
Abilita la fotocamera se non è già abilitata, quindi riavvia se viene richiesto.
1. Verifica che la fotocamera funzioni digitando il comando seguente:
```
raspistill -v -o test.jpg
```
Se la fotocamera è configurata correttamente, questo comando acquisisce un'immagine dalla fotocamera, la salva in un file denominato e visualizza messaggi `test.jpg` informativi.
------
#### [ Camera module 2 or 3 ]
Se utilizzi un modulo Camera 2, utilizzi `bcm2835-v4l2` (legacy) o `libcamera` (moderno). Tuttavia, lo `libcamera` stack è consigliato per migliorare il supporto e le funzionalità. Segui i passaggi seguenti per confermare che `libcamera` sia up-to-date sul tuo sistema.
1. [libcamera](https://www.raspberrypi.com/documentation/computers/camera_software.html#libcamera) dovrebbe essere preinstallata sul tuo Raspberry Pi. Verifica la presenza di eventuali aggiornamenti e aggiorna alla versione più recente per correzioni di bug e aggiornamenti di sicurezza. Apri il terminale e digita i seguenti comandi:
```
sudo apt-get update
sudo apt-get upgrade
```
1. Riavvia il sistema per rendere effettivi gli aggiornamenti.
```
sudo reboot
```
1. Metti alla prova la tua fotocamera. Questa applicazione avvia uno streaming di anteprima della videocamera e lo visualizza sullo schermo.
```
libcamera-hello
```
Se hai problemi con il modulo della fotocamera, consulta la [documentazione di Raspberry Pi per la](https://raspberrypi.com/documentation/computers/camera_software.html#troubleshooting) risoluzione dei problemi.
------
# Installa i prerequisiti del software
L'SDK C\$1\$1 Producer richiede l'installazione dei seguenti prerequisiti software su Raspberry Pi.
1. Aggiorna l'elenco dei pacchetti e installa le librerie necessarie per creare l'SDK. Apri il terminale e digita i seguenti comandi:
```
sudo apt-get update
sudo apt-get install -y \
automake \
build-essential \
cmake \
git \
gstreamer1.0-plugins-base-apps \
gstreamer1.0-plugins-bad \
gstreamer1.0-plugins-good \
gstreamer1.0-plugins-ugly \
gstreamer1.0-tools \
gstreamer1.0-omx-generic \
libcurl4-openssl-dev \
libgstreamer1.0-dev \
libgstreamer-plugins-base1.0-dev \
liblog4cplus-dev \
libssl-dev \
pkg-config
```
1. Se stai usando lo `libcamera` stack, installa anche il `libcamerasrc` GStreamer plugin. Questo GStreamer plugin non viene installato di default.
```
sudo apt-get install gstreamer1.0-libcamera
```
1. Copia il file PEM seguente in `/etc/ssl/cert.pem`:
```
sudo curl https://www.amazontrust.com/repository/AmazonRootCA1.pem -o /etc/ssl/AmazonRootCA1.pem
sudo chmod 644 /etc/ssl/AmazonRootCA1.pem
```
# Scarica e crea l'SDK per produttori Kinesis Video Streams C\$1\$1
Segui le procedure seguenti per scaricare e creare l'SDK per [produttori Kinesis Video Streams](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) C\$1\$1. Assicurati di aver installato i prerequisiti del software; consulta questi passaggi. [Installa i prerequisiti del software](producersdk-cpp-rpi-software.md)
1. Vai alla directory dei download. Apri un terminale e passa alla cartella di download preferita.
Esempio:
```
cd ~/Downloads
```
1. Clona il repository SDK. Usa il `git clone` comando per scaricare l'SDK dal repository. GitHub Type:
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git --single-branch -b master kvs-producer-sdk-cpp
```
Questo comando clona solo un singolo ramo (il `master` ramo), riducendo le dimensioni e il tempo di download. Inoltre, inserisce i contenuti scaricati in una cartella chiamata `kvs-producer-sdk-cpp` all'interno della directory corrente.
1. Verifica il download. Una volta completato il processo di clonazione, elenca il contenuto della `kvs-producer-sdk-cpp` cartella per verificare che l'SDK sia stato scaricato.
```
ls kvs-producer-sdk-cpp
```
1. Preparate una cartella di compilazione. Type:
```
mkdir -p kvs-producer-sdk-cpp/build
cd kvs-producer-sdk-cpp/build
```
1. Configura la build. Esegui il `cmake` comando seguente per configurare l'ambiente di compilazione con opzioni specifiche:
```
cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON
```
[CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html)utilizza le seguenti opzioni per generare le opzioni appropriate`Makefiles`:
+ Utilizzo della cartella del progetto (`..`) come directory di origine.
+ Utilizzo della directory corrente (`.`) (`build/`) per l'output della build.
+ `-DBUILD_GSTREAMER_PLUGIN=ON`abilita la creazione del GStreamer plugin kvssink.
+ `-DBUILD_DEPENDENCIES=OFF`disabilita la creazione di dipendenze esterne dal sorgente. Il progetto troverà e utilizzerà le dipendenze esterne installate in un passaggio precedente.
+ `-DALIGNED_MEMORY_MODEL=ON`disabilita il modello di memoria non allineata. L'accesso non allineato alla memoria non è supportato da alcuni dispositivi Raspberry Pi.
**Nota**
Per un elenco completo degli CMake argomenti, vedere. [Scarica e configura il codice della libreria C\$1\$1 Producer](producersdk-cpp-download.md)
1. Compilare il progetto. Dopo aver configurato la build, usa il `make` comando per compilare usando il comando `Makefile` generato da. `cmake`
```
make -j$(nproc)
```
L'`-j`argomento per gli `make` consente di eseguire più lavori di compilazione in parallelo. Per ridurre i tempi di compilazione, usa il `nproc` comando per calcolare dinamicamente il numero di core della CPU sul tuo Raspberry Pi.
1. Conferma che sia presente`libgstkvssink.so`.
Elenca i file nella directory corrente.
**Richiesta:**
```
ls
```
**Risposta:**
```
CMakeCache.txt dependency kvs_gstreamer_sample
CMakeFiles kvs_gstreamer_audio_video_sample kvssink_gstreamer_sample
Makefile kvs_gstreamer_file_uploader_sample libKinesisVideoProducer.so
cmake_install.cmake kvs_gstreamer_multistream_sample libgstkvssink.so
```
1. Conferma che GStreamer può essere caricato`kvssink`.
Imposta la variabile di `GST_PLUGIN_PATH` ambiente sulla directory contenente`libgstkvssink.so`.
```
export GST_PLUGIN_PATH=`pwd`
```
Hai un GStreamer carico`kvssink`:
```
gst-inspect-1.0 kvssink
```
Dovresti vedere della documentazione su`kvssink`. Usa i tasti freccia per navigare e premi `q` per uscire.
1. (**Facoltativo**) Aggiorna lo script di avvio della shell per includere l'impostazione della variabile di `GST_PLUGIN_PATH` ambiente. Questo assicura che `GST_PLUGIN_PATH` sia impostato correttamente durante una nuova sessione di terminale. Sui dispositivi Raspberry Pi, lo script di avvio della shell è. `~/.bashrc`
Esegui il comando seguente per aggiungere il comando alla fine dello script di avvio della shell.
```
echo "export GST_PLUGIN_PATH=~/Downloads/kvs-producer-sdk-cpp/build" >> ~/.bashrc
```
Digitate quanto segue per eseguire lo script di avvio della shell oppure chiudere la shell corrente e aprirne una nuova.
```
source ~/.bashrc
```
Conferma che `GST_PLUGIN_PATH` è impostato e puoi `kvssink` caricarlo.
```
echo $GST_PLUGIN_PATH
```
```
gst-inspect-1.0 kvssink
```
# 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`
# Riproduci contenuti multimediali dal tuo flusso video Kinesis
Apri la console [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams e **seleziona il nome dello stream che** hai creato.
Il flusso di video inviato da Raspberry Pi viene visualizzato nella console.
**Nota**
Potrebbero essere necessari alcuni secondi prima che il video venga visualizzato nella console.
Una volta riprodotto lo streaming, puoi provare le seguenti funzionalità della console:
+ Nella sezione **Video preview (Anteprima video)** usa i controlli di navigazione per riavvolgere o far avanzare rapidamente il flusso.
+ Nella sezione **Informazioni sullo stream**, esamina il codec, la risoluzione e la velocità in bit dello stream. I valori di risoluzione e bit rate sono volutamente bassi sul Raspberry Pi per ridurre al minimo l'utilizzo della larghezza di banda per questo tutorial.
Per visualizzare le CloudWatch metriche Amazon che vengono create per il tuo stream, seleziona **Visualizza le metriche dello stream in**. CloudWatch
+ Sotto **Data retention period (Periodo di retention dei dati)**, nota che il flusso di video viene conservato per un giorno. Puoi modificare questo valore e impostarlo su **No data retention (Nessuna retention dei dati)** oppure impostare un valore compreso tra un giorno e diversi anni.
+ In **Crittografia lato server**, nota che i tuoi dati vengono crittografati quando sono inattivi utilizzando una chiave gestita da (). AWS Key Management Service AWS KMS
## Problemi di riproduzione
Di seguito sono riportati alcuni problemi di riproduzione che si verificano di frequente e come risolverli.
### Nessun file multimediale, ma nei log sono presenti dei PERSISTED ACK
Se vedi PERSISTED Acks nei log, significa che Kinesis Video Streams ha importato e archiviato con successo i file multimediali caricati da. `kvssink` Gli Ack ricevuti da Kinesis Video Streams hanno questo aspetto. Nel formato JSON, guarda il valore della chiave. `"EventType"`
```
{"EventType":"RECEIVED","FragmentTimecode":252200,"FragmentNumber":"12345678901234567890123456724587702494771079511"}
{"EventType":"BUFFERING","FragmentTimecode":252467,"FragmentNumber":"12345678901234567890123456781729223736853277017"}
{"EventType":"RECEIVED","FragmentTimecode":252467,"FragmentNumber":"12345678901234567890123456781729223736853277017"}
{"EventType":"BUFFERING","FragmentTimecode":253000,"FragmentNumber":"12345678901234567890123456738870744847093249408"}
{"EventType":"PERSISTED","FragmentTimecode":252200,"FragmentNumber":"12345678901234567890123456724587702494771079511"}
{"EventType":"PERSISTED","FragmentTimecode":252467,"FragmentNumber":"1234567890123456789012345671729223736853277017"}
```
**Risoluzione:**
Attendi uno o due minuti nella console Kinesis Video Streams, quindi usa la doppia freccia destra. Se non viene visualizzato alcun file multimediale, verifica che lo stream venga inviato nella regione corretta e controlla l'ortografia del nome dello stream. Puoi trovare queste informazioni nei log.
Vedi [Fornisci una regione a `kvssink`](examples-gstreamer-plugin-parameters.md#kvssink-region) per maggiori informazioni su come kvssink determina quale regione usare.
### Il caricamento del file multimediale impiega molto tempo nel Console di gestione AWS
**Importante**
L'esperienza di riproduzione su console è diversa da quella di riproduzione in HLS e DASH. Usa anche la [pagina web ospitata](https://aws-samples.github.io/amazon-kinesis-video-streams-media-viewer/) dal lettore multimediale di esempio GitHub per testare la riproduzione. [Il codice sorgente della pagina web può essere trovato qui.](https://github.com/aws-samples/amazon-kinesis-video-streams-media-viewer)
I file multimediali possono caricarsi lentamente nella console a causa della scarsa larghezza di banda della rete o di un dispositivo limitato, ma possono anche essere correlati alla codifica e alla frammentazione del video.
**Nozioni di base sulla codifica video:**
+ Gli encoder H.264 e H.265 utilizzano fotogrammi chiave (I-Frames) e frame previsti (P-Frames) per una compressione efficiente.
+ I keyframe contengono dati di immagine completi, mentre i fotogrammi P contengono solo modifiche rispetto ai frame precedenti.
+ L' "intervallo fotogrammi chiave» determina la frequenza con cui i fotogrammi chiave vengono visualizzati nel flusso video.
**Frammentazione in streaming:**
+ In Kinesis Video Streams, i nuovi frammenti iniziano con ogni fotogramma chiave. Per ulteriori informazioni, consulta [Modello di dati Kinesis Video Streams](how-data.md).
+ **La lunghezza del frammento (in secondi) può essere stimata come: intervallo di fotogrammi chiave ÷ frequenza fotogrammi**
**Esempio**:
Per uno stream con un intervallo di fotogrammi chiave di 30 e un frame rate di 15 fps:
Lunghezza del frammento = 30 ÷ 15 = 2 secondi
A causa di intervalli di fotogrammi chiave più ampi, i frammenti più lunghi aumentano la latenza nei contenuti multimediali in streaming.
**Risoluzione:**
Per migliorare i tempi di caricamento, prendete in considerazione la possibilità di ridurre l'intervallo tra i fotogrammi chiave. Ciò creerà frammenti più brevi, diminuendo la latenza, ma aumenterà anche la dimensione del file video.
Per l'`x264enc` GStreamer elemento, puoi impostare in modo esplicito l'intervallo chiave-fotogramma tramite la proprietà: `key-int-max`
```
x264enc bframes=0 key-int-max=60
```
Durante la revisione dell'output del registro, nota la frequenza con cui il client di caricamento riceve ACKs da Kinesis Video Streams. Maggiore è il numero di fotogrammi chiave generati, maggiore è il numero ACKs di fotogrammi chiave restituiti.
### Il file multimediale è distorto o presenta artefatti
Per risolvere questo problema, assicuratevi che tutti i cavi siano collegati saldamente. Esamina l'output di `libcamera-hello` (o `raspistill` per le fotocamere Pi precedenti) per i moduli telecamera.
Nella tua GStreamer pipeline, sostituiscilo `kvssink` con `autovideosink` o `matroskamux` e`filesink`. Esempio:
```
... x264enc tune=zerolatency speed-preset=ultrafast bframes=0 key-int-max=60 byte-stream=true ! h264parse ! matroskamux ! filesink location=output.mkv
```
Controlla il file di output `filesink` o il lettore multimediale che si apre quando lo usi `autovideosink` per vedere se anche gli artefatti sono presenti.
Esamina anche l'output della seguente pipeline:
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
L'aggiunta di elementi alla pipeline, come [dewarp](https://gstreamer.freedesktop.org/documentation/opencv/dewarp.html?gi-language=c), può correggere le uscite delle telecamere fish eye.
Controlla i codec di output supportati per la tua fotocamera e regola gli elementi secondo necessità.
Ad esempio, se la fotocamera USB supporta solo l'output JPEG, sarà necessario utilizzare `jpegdec` gli elementi `jpegparse` and per trasformare il file multimediale prima di codificarlo in H.264 utilizzando. `x264enc` Cerca assistenza GStreamer nei forum per altri utenti con pipeline e/o configurazioni di webcam simili.
# Risoluzione dei problemi di compilazione su C\$1\$1 Producer SDK per Raspberry Pi
Se riscontri un problema di compilazione e desideri provare CMake argomenti diversi, assicurati di eseguire una build pulita. Elimina le `build` cartelle `open-source``dependency`, e prima di riprovare.
## Problemi di creazione con OpenSSL
Se ricevete un output simile al seguente, significa che OpenSSL ha rilevato erroneamente l'architettura del sistema.
```
crypto/md5/md5-aarch64.S: Assembler messages:
crypto/md5/md5-aarch64.S:3: Error: unrecognized symbol type ""
crypto/md5/md5-aarch64.S:6: Error: bad instruction `stp x19,x20,[sp,#-80]!'
crypto/md5/md5-aarch64.S:7: Error: bad instruction `stp x21,x22,[sp,#16]'
crypto/md5/md5-aarch64.S:8: Error: bad instruction `stp x23,x24,[sp,#32]'
crypto/md5/md5-aarch64.S:9: Error: bad instruction `stp x25,x26,[sp,#48]'
```
In questo esempio, sta tentando di creare una versione a 64 bit (`linux-aarch64`) quando questo Raspberry Pi è in realtà a 32 bit. Alcuni dispositivi Raspberry Pi hanno un kernel a 64 bit, ma uno spazio utente a 32 bit.
Determina per quale architettura OpenSSL sta cercando di creare. Puoi trovare la riga di registro durante la `configure` fase per OpenSSL:
```
[ 33%] Performing update step for 'project_libopenssl'
-- Already at requested tag: OpenSSL_1_1_1t
[ 44%] No patch step for 'project_libopenssl'
[ 55%] Performing configure step for 'project_libopenssl'
Operating system: x86_64-whatever-linux2
Configuring OpenSSL version 1.1.1t (0x1010114fL) for linux-x86_64
Using os-specific seed configuration
Creating configdata.pm
Creating Makefile
```
Verifica l'architettura del tuo sistema:
+ Controlla la bitness del kernel: esegui `uname -m`
+ Verifica la dimensione in bit dello spazio utente: run `getconf LONG_BIT`
Puoi anche rivedere le informazioni sulla CPU con i comandi `cat /proc/cpuinfo` or`lscpu`.
**Risoluzione:**
Per risolvere questo problema, aggiungi il seguente CMake argomento durante la compilazione, per assicurarti che OpenSSL venga compilato correttamente per l'architettura ARM a 32 bit:
```
-DBUILD_OPENSSL_PLATFORM=linux-armv4
```
## Risolvi i problemi di caricamento in `kvssink` GStreamer
Conferma `GST_PLUGIN_PATH`
Assicurati che la variabile di `GST_PLUGIN_PATH` ambiente nella sessione di shell corrente punti alla directory contenente`kvssink`. Le variabili di ambiente sono specifiche della sessione, quindi dovrai impostarle per ogni nuova sessione. Per rendere permanente questa modifica, vedi «Aggiorna lo script di avvio della shell per includere l'impostazione della variabile di ambiente GST\$1PLUGIN\$1PATH».
**Errore: impossibile aprire il file oggetto condiviso: nessun file o directory di questo tipo**
Se si verifica l'errore`Cannot open shared object file: No such file or directory`, esegui il comando seguente:
```
gst-inspect-1.0 /path/to/libgstkvssink.so
```
Se ricevete il seguente output, significa che il linker dinamico non è in grado di individuare le librerie richieste per`kvssink`. Ciò si verifica in genere a causa di:
+ `kvssink`Trasferimento in un luogo diverso da quello in cui è stato costruito.
+ Compilazione incrociata per l'architettura della CPU sbagliata.
+ Manca una dipendenza richiesta.
**Output:**
```
WARNING: erroneous pipeline: no element "kvssink"
error while loading shared libraries: libcproducer.so: cannot open shared object file: No such file or directory
```
**Risoluzione:**
Per le **librerie spostate**, aggiungi la directory contenente le librerie mancanti a`LD_LIBRARY_PATH`.
Dalla directory principale del repository originale, è possibile individuare la libreria mancante utilizzando l'`find`utilità. Nel terminale, digitate:
```
find . -name "*libcproducer*"
```
**Output:**
```
./build/dependency/libkvscproducer/kvscproducer-src/libcproducer.so
```
Il separatore del percorso dei file sui dispositivi Linux è`:`. Il comando seguente aggiunge un nuovo percorso di cartella alla variabile di `LD_LIBRARY_PATH` ambiente esistente, preservando i valori precedenti.
Nel tuo terminale, digita:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/build/dependency/libkvscproducer/kvscproducer-src
```
**Importante**
Le variabili di ambiente sono specifiche della sessione. Per mantenere le modifiche tra le sessioni, modifica lo script di avvio della shell.
Potrebbe anche essere necessario aggiungere il file `open-source/local/lib` al tuo`$LD_LIBRARY_PATH`.
**Errore:. /path/to/libcproducer.so.1:** intestazione ELF non valida
Se ricevi questo errore durante il caricamento delle **librerie condivise**, potrebbe essere dovuto a collegamenti simbolici non funzionanti (). `symlinks` I collegamenti simbolici possono interrompersi se il sistema operativo della macchina host non corrisponde a quello della macchina di destinazione. Ad esempio, la compilazione incrociata su un Raspberry MacBook Pi.
Un'altra possibile causa è che i file binari compilati erano per l'architettura sbagliata. Ad esempio, se i binari sono stati creati per x86 (Raspberry Pi utilizza ARM). CPUs
Vai alla posizione della libreria specificata nell'errore e digita: `ls -la` per ispezionare la libreria. `symlinks`
**Risposta:**
```
drwxr-xr-x 16 me staff 512 Sep 10 17:16 .
drwxr-xr-x 7 me staff 224 Jan 6 23:46 ..
drwxr-xr-x 4 me staff 128 Sep 10 17:16 engines-1.1
-rwxr-xr-x 1 me staff 2294496 Sep 10 17:16 libcrypto.1.1.so
-rw-r--r-- 1 me staff 4002848 Sep 10 17:16 libcrypto.a
lrwxr-xr-x 1 me staff 19 Sep 10 17:16 libcrypto.so -> libcrypto.1.1.so
-rwxr-xr-x 1 me staff 631176 Sep 10 17:12 liblog4cplus-2.0.3.so
lrwxr-xr-x 1 me staff 24 Sep 10 17:12 liblog4cplus.so -> liblog4cplus-2.0.3.so
-rwxr-xr-x 1 me staff 1012 Sep 10 17:12 liblog4cplus.a
-rwxr-xr-x 1 me staff 694328 Sep 10 17:12 liblog4cplusU-2.0.3.so
lrwxr-xr-x 1 me staff 25 Sep 10 17:12 liblog4cplusU.dylib -> liblog4cplusU-2.0.3.so
-rwxr-xr-x 1 me staff 1017 Sep 10 17:12 liblog4cplusU.a
-rwxr-xr-x 1 me staff 536416 Sep 10 17:16 libssl.1.1.so
-rw-r--r-- 1 me staff 795184 Sep 10 17:16 libssl.a
lrwxr-xr-x 1 me staff 16 Sep 10 17:16 libssl.so -> libssl.1.1.so
drwxr-xr-x 6 me staff 192 Sep 10 17:16 pkgconfig
```
Nell'output di esempio riportato sopra, non `symlinks` sono interrotti. Broken `symlinks` non avrà frecce che puntano verso i bersagli.
**Risoluzione:**
Esistono due opzioni per correggere i collegamenti simbolici:
+ **Consigliato:** ricrea il file `symlink` con il `ln` comando. Type:
```
ln -s /path/to/actual/library /path/to/symlink
```
+ Copiate il file della libreria attuale e rinominatelo in modo che corrisponda a. `symlink`
**Nota**
Questa opzione comporta un maggiore utilizzo dello spazio di archiviazione.
Come best practice, compila sullo stesso sistema operativo utilizzando strumenti come Docker per evitare problemi di compilazione incrociata.
**Dipendenze mancanti:**
Se il nome della libreria mancante inizia con`libkvs`, consulta la sezione precedente dedicata alle «librerie spostate» per installare le librerie Kinesis Video Streams dal dispositivo host al dispositivo di destinazione.
Altrimenti, segui questa procedura [Installa i prerequisiti del software](producersdk-cpp-rpi-software.md) per assicurarti che tutti i prerequisiti del software open source siano installati sul dispositivo di destinazione.