Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Gunakan SDK produsen C \$1\$1 di Raspberry Pi
Raspberry Pi adalah komputer kecil dan murah yang dapat digunakan untuk mengajar dan mempelajari keterampilan pemrograman komputer dasar. Tutorial ini menjelaskan bagaimana Anda dapat mengatur dan menggunakan SDK produser Amazon Kinesis Video Streams C \$1\$1 pada perangkat Raspberry Pi. Langkah-langkahnya juga mencakup cara memverifikasi instalasi menggunakan aplikasi GStreamer demo.
**Topics**
+ [Prasyarat](producersdk-cpp-rpi-prerequisites.md)
+ [Buat pengguna IAM dengan izin untuk menulis ke Kinesis Video Streams](producersdk-cpp-rpi-iam.md)
+ [Bergabunglah dengan Raspberry Pi Anda ke jaringan Wi-Fi Anda](producersdk-cpp-rpi-wifi.md)
+ [Connect dari jarak jauh ke Raspberry Pi Anda](producersdk-cpp-rpi-connect.md)
+ [Konfigurasikan kamera Raspberry Pi](producersdk-cpp-rpi-camera.md)
+ [Instal prasyarat perangkat lunak](producersdk-cpp-rpi-software.md)
+ [Unduh dan buat SDK produser Kinesis Video Streams C \$1\$1](producersdk-cpp-rpi-download.md)
+ [Streaming video ke aliran video Kinesis Anda](producersdk-cpp-rpi-run.md)
+ [Putar kembali media dari aliran video Kinesis Anda](producersdk-cpp-rpi-playback.md)
+ [Memecahkan masalah build pada SDK produsen C \$1\$1 untuk Raspberry Pi](troubleshoot-rpi.md)
# Prasyarat
Sebelum Anda mengatur SDK produsen C \$1\$1 pada Raspberry Pi Anda, pastikan Anda memiliki prasyarat berikut:
+ Perangkat Raspberry Pi dengan konfigurasi berikut:
+ Versi papan: 3 Model B atau yang lebih baru.
+ [Modul kamera](https://www.raspberrypi.com/documentation/accessories/camera.html) yang terhubung atau kamera USB yang terhubung (web cam).
+ Kartu SD dengan kapasitas minimal 8 GB.
+ Sistem operasi Raspbian (kernel versi 4.9 atau yang lebih baru) diinstal. Anda dapat mengunduh gambar Raspberry Pi OS (sebelumnya disebut Raspbian) terbaru dari [situs web Raspberry Pi](https://www.raspberrypi.com/software/). Ikuti petunjuk Raspberry Pi untuk [menginstal gambar yang diunduh pada kartu SD](https://www.raspberrypi.com/documentation/computers/getting-started.html#install-an-operating-system).
+ Sebuah Akun AWS dengan aliran video Kinesis. Untuk informasi selengkapnya, lihat [Memulai dengan Kinesis Video Streams](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html).
# Buat pengguna IAM dengan izin untuk menulis ke Kinesis Video Streams
Jika Anda belum melakukannya, siapkan pengguna AWS Identity and Access Management (IAM) dengan izin untuk menulis ke aliran video Kinesis.
Prosedur ini dimaksudkan untuk membantu Anda memulai dengan cepat menggunakan AWS access key pair. Perangkat dapat menggunakan sertifikat X.509 untuk terhubung. AWS IoT Lihat [Mengontrol akses ke sumber daya Kinesis Video Streams menggunakan AWS IoT](how-iot.md) untuk informasi selengkapnya tentang cara mengonfigurasi perangkat agar menggunakan autentikasi berbasis sertifikat.
1. Masuk ke Konsol Manajemen AWS dan buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Di menu navigasi di sebelah kiri, pilih **Pengguna**.
1. Untuk membuat pengguna baru, pilih **Tambah pengguna**.
1. Berikan **nama Pengguna** deskriptif untuk pengguna, seperti**kinesis-video-raspberry-pi-producer**.
1. Di bawah **Jenis akses**, pilih **Akses terprogram**.
1. Pilih **Berikutnya: Izin**.
1. Di bawah **Setel izin untuk kinesis-video-raspberry-pi -produser**, pilih **Lampirkan kebijakan yang ada** secara langsung.
1. Pilih **Buat kebijakan**. Halaman **Buat kebijakan** terbuka di tab browser web baru.
1. Pilih tab **JSON**.
1. Salin kebijakan JSON berikut dan tempelkan ke area teks. Kebijakan ini memberikan izin kepada pengguna Anda untuk membuat dan menulis data ke aliran video Kinesis.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"kinesisvideo:DescribeStream",
"kinesisvideo:CreateStream",
"kinesisvideo:GetDataEndpoint",
"kinesisvideo:PutMedia"
],
"Resource": [
"*"
]
}]
}
```
------
1. Pilih **Tinjau kebijakan**.
1. Berikan **nama** untuk kebijakan Anda, seperti**kinesis-video-stream-write-policy**.
1. Pilih **Buat kebijakan**.
1. Kembali ke tab **Tambah pengguna** di browser Anda, dan pilih **Segarkan**.
1. Di kotak pencarian, ketikkan nama kebijakan yang Anda buat.
1. Pilih kotak centang di samping kebijakan baru Anda dalam daftar.
1. Pilih **Berikutnya: Tinjauan**.
1. Pilih **Create user** (Buat pengguna).
1. Konsol menampilkan **ID kunci Akses** untuk pengguna baru Anda. Pilih **Tampilkan** untuk menampilkan **kunci akses Rahasia**. Catat nilai-nilai ini; mereka diperlukan saat Anda mengkonfigurasi aplikasi.
# Bergabunglah dengan Raspberry Pi Anda ke jaringan Wi-Fi Anda
Jika Anda menggunakan monitor dan keyboard yang terpasang, lanjutkan ke[Konfigurasikan kamera Raspberry Pi](producersdk-cpp-rpi-camera.md).
Instruksi ini ditulis untuk membantu Anda mengatur Raspberry Pi Anda saat dijalankan dalam mode *tanpa kepala*, yaitu, tanpa keyboard, monitor, atau kabel jaringan yang terpasang. Ikuti petunjuk di bawah ini untuk mengkonfigurasi Raspberry Pi Anda untuk secara otomatis mencoba menghubungkan ke jaringan yang ditentukan, memungkinkan mesin host Anda untuk dapat SSH ke dalamnya.
1. Di komputer Anda, buat file bernama`wpa_supplicant.conf`.
1. Salin teks berikut dan tempel ke dalam `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"
}
```
Ganti `ssid` dan `psk` nilai dengan informasi untuk jaringan Wi-Fi Anda.
1. Salin `wpa_supplicant.conf` file ke kartu SD. Itu harus disalin ke root `boot` volume.
1. Masukkan kartu SD ke Raspberry Pi, dan nyalakan perangkat. Ini bergabung dengan jaringan Wi-Fi Anda, dan SSH diaktifkan.
# Connect dari jarak jauh ke Raspberry Pi Anda
Jika Anda menggunakan monitor dan keyboard yang terpasang, lanjutkan ke[Konfigurasikan kamera Raspberry Pi](producersdk-cpp-rpi-camera.md).
Instruksi ini ditulis untuk membantu Anda mengatur Raspberry Pi Anda saat dijalankan dalam mode *tanpa kepala*, yaitu, tanpa keyboard, monitor, atau kabel jaringan yang terpasang. Ikuti petunjuk di bawah ini untuk menemukan Raspberry Pi Anda di jaringan Anda dan SSH ke dalamnya dari mesin host Anda.
1. Sebelum menghubungkan ke perangkat Raspberry Pi Anda dari jarak jauh, lakukan salah satu hal berikut untuk menentukan alamat IP-nya:
+ Jika Anda memiliki akses ke router Wi-Fi jaringan Anda, lihat perangkat Wi-Fi yang terhubung. Temukan perangkat yang diberi nama `Raspberry Pi` untuk menemukan alamat IP perangkat Anda.
+ Jika Anda tidak memiliki akses ke router Wi-Fi jaringan Anda, Anda dapat menggunakan perangkat lunak lain untuk menemukan perangkat di jaringan Anda. [Fing](https://www.fing.com/) adalah aplikasi populer yang tersedia untuk perangkat Android dan iOS. Anda dapat menggunakan versi gratis aplikasi ini untuk menemukan alamat IP perangkat di jaringan Anda.
1. Ketika Anda mengetahui alamat IP perangkat Raspberry Pi, Anda dapat menggunakan aplikasi terminal apa pun untuk terhubung.
+ Di macOS atau Linux, gunakan: `ssh`
```
ssh pi@
```
+ Di Windows, gunakan [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html), klien SSH gratis untuk Windows.
Untuk instalasi baru Raspbian, nama pengguna adalah**pi**, dan kata sandinya**raspberry**. Kami menyarankan Anda [mengubah kata sandi default](https://www.raspberrypi.com/documentation/computers/configuration.html#change-user-password-nonint).
# Konfigurasikan kamera Raspberry Pi
Ikuti langkah-langkah ini untuk mengonfigurasi [modul kamera Raspberry Pi](https://www.raspberrypi.com/documentation/accessories/camera.html) untuk mengirim video dari perangkat ke aliran video Kinesis.
**catatan**
Jika Anda menggunakan kamera web USB, lewati ke[Instal prasyarat perangkat lunak](producersdk-cpp-rpi-software.md).
------
#### [ Camera module 1 ]
Ikuti petunjuk ini untuk memperbarui file modul, mengaktifkan antarmuka kamera, dan memverifikasi fungsionalitas kamera Anda. Memperbarui file modul memberi tahu Raspberry Pi modul kernel mana yang akan dimuat saat boot. Driver kamera tidak dimuat secara default untuk menghemat sumber daya sistem pada perangkat Raspberry Pi yang tidak menggunakan kamera.
1. Buka editor untuk membuat perubahan pada file modul. Buka terminal dan gunakan perintah berikut untuk mengedit file menggunakan `nano` editor:
```
sudo nano /etc/modules
```
1. Tambahkan baris berikut ke akhir file, jika belum ada:
```
bcm2835-v4l2
```
1. Simpan file dan keluar dari editor. Untuk menyimpan dan keluar menggunakan `nano` editor, gunakan Ctrl\$1X.
1. Nyalakan ulang Raspberry Pi:
```
sudo reboot
```
1. Saat perangkat reboot, sambungkan lagi melalui aplikasi terminal Anda jika Anda terhubung dari jarak jauh.
1. Buka`raspi-config`:
```
sudo raspi-config
```
1. Pilih **Opsi Antarmuka**, Kamera **Lama.** **Dalam versi lama dari Sistem Operasi Raspbian, opsi menu ini mungkin berada di bawah Opsi **Antarmuka**, Kamera.**
Aktifkan kamera jika belum diaktifkan, dan reboot jika diminta.
1. Verifikasi bahwa kamera bekerja dengan mengetikkan perintah berikut:
```
raspistill -v -o test.jpg
```
Jika kamera Anda dikonfigurasi dengan benar, perintah ini menangkap gambar dari kamera, menyimpannya ke file bernama`test.jpg`, dan menampilkan pesan informasi.
------
#### [ Camera module 2 or 3 ]
Jika Anda menggunakan modul Kamera 2, Anda menggunakan `bcm2835-v4l2` (lama) atau `libcamera` (modern). Namun, `libcamera` tumpukan direkomendasikan untuk dukungan dan fitur yang lebih baik. Ikuti langkah-langkah di bawah ini untuk mengonfirmasi bahwa `libcamera` ada up-to-date di sistem Anda.
1. [libcamera](https://www.raspberrypi.com/documentation/computers/camera_software.html#libcamera) harus sudah diinstal sebelumnya pada Raspberry Pi Anda. Periksa pembaruan dan pembaruan ke versi terbaru untuk perbaikan bug dan pembaruan keamanan. Buka terminal dan ketik perintah berikut:
```
sudo apt-get update
sudo apt-get upgrade
```
1. Reboot sistem Anda agar pembaruan diterapkan.
```
sudo reboot
```
1. Uji kamera Anda. Aplikasi ini memulai aliran pratinjau kamera dan menampilkannya di layar.
```
libcamera-hello
```
Jika Anda memiliki masalah dengan modul kamera Anda, lihat [dokumentasi Raspberry Pi](https://raspberrypi.com/documentation/computers/camera_software.html#troubleshooting) untuk pemecahan masalah.
------
# Instal prasyarat perangkat lunak
SDK produsen C \$1\$1 mengharuskan Anda menginstal prasyarat perangkat lunak berikut pada Raspberry Pi.
1. Perbarui daftar paket dan instal pustaka yang diperlukan untuk membangun SDK. Buka terminal dan ketik perintah berikut:
```
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. Jika Anda menggunakan `libcamera` tumpukan, instal juga `libcamerasrc` GStreamer plugin. GStreamer Plugin ini tidak diinstal secara default.
```
sudo apt-get install gstreamer1.0-libcamera
```
1. Salin file PEM berikut ke`/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
```
# Unduh dan buat SDK produser Kinesis Video Streams C \$1\$1
Ikuti prosedur di bawah ini untuk mengunduh dan membangun SDK [produser Kinesis Video Streams](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) C\$1\$1. Pastikan Anda telah menginstal prasyarat perangkat lunak; lihat [Instal prasyarat perangkat lunak](producersdk-cpp-rpi-software.md) langkah-langkah itu.
1. Arahkan untuk mengunduh direktori. Buka terminal dan ubah ke direktori unduhan pilihan Anda.
Contoh:
```
cd ~/Downloads
```
1. Kloning repositori SDK. Gunakan `git clone` perintah untuk mengunduh SDK dari GitHub repositori. Jenis:
```
git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp.git --single-branch -b master kvs-producer-sdk-cpp
```
Perintah ini hanya mengkloning satu cabang (`master`cabang), mengurangi ukuran dan waktu unduhan. Ini juga menempatkan konten yang diunduh ke dalam folder yang disebut `kvs-producer-sdk-cpp` dalam direktori saat ini.
1. Verifikasi unduhan. Setelah proses kloning selesai, daftarkan konten `kvs-producer-sdk-cpp` folder untuk memverifikasi bahwa SDK telah diunduh.
```
ls kvs-producer-sdk-cpp
```
1. Siapkan direktori build. Jenis:
```
mkdir -p kvs-producer-sdk-cpp/build
cd kvs-producer-sdk-cpp/build
```
1. Konfigurasikan build. Jalankan `cmake` perintah berikut untuk mengonfigurasi lingkungan build dengan opsi tertentu:
```
cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON
```
[CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html)menggunakan opsi berikut untuk menghasilkan yang sesuai`Makefiles`:
+ Menggunakan folder proyek (`..`) sebagai direktori sumber.
+ Menggunakan direktori saat ini (`.`) (`build/`) untuk keluaran build.
+ `-DBUILD_GSTREAMER_PLUGIN=ON`memungkinkan pembangunan GStreamer plugin kvssink.
+ `-DBUILD_DEPENDENCIES=OFF`menonaktifkan membangun dependensi eksternal dari sumber. Proyek akan menemukan dan menggunakan dependensi eksternal yang diinstal pada langkah sebelumnya.
+ `-DALIGNED_MEMORY_MODEL=ON`menonaktifkan model memori yang tidak selaras. Akses memori yang tidak selaras tidak didukung oleh perangkat Raspberry Pi tertentu.
**catatan**
Untuk daftar lengkap CMake argumen, lihat[Unduh dan konfigurasikan kode pustaka produser C\$1\$1](producersdk-cpp-download.md).
1. Bangun proyek. Setelah mengonfigurasi build, gunakan `make` perintah untuk mengkompilasi menggunakan yang `Makefile` dihasilkan oleh. `cmake`
```
make -j$(nproc)
```
`-j`Argumen untuk `make` memungkinkannya menjalankan beberapa pekerjaan kompilasi secara paralel. Untuk mengurangi waktu pembuatan, gunakan `nproc` perintah untuk menghitung secara dinamis jumlah core CPU pada Raspberry Pi Anda.
1. Konfirmasikan bahwa `libgstkvssink.so` ada.
Buat daftar file di direktori saat ini.
**Prompt:**
```
ls
```
**Tanggapan:**
```
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. Konfirmasikan bahwa GStreamer dapat memuat`kvssink`.
Atur variabel `GST_PLUGIN_PATH` lingkungan ke direktori yang berisi`libgstkvssink.so`.
```
export GST_PLUGIN_PATH=`pwd`
```
Memiliki GStreamer beban`kvssink`:
```
gst-inspect-1.0 kvssink
```
Anda akan melihat beberapa dokumentasi tentang`kvssink`. Gunakan tombol panah untuk menavigasi dan tekan `q` untuk keluar.
1. (**Opsional**) Perbarui skrip start-up shell Anda untuk menyertakan pengaturan variabel `GST_PLUGIN_PATH` lingkungan. Ini memastikan `GST_PLUGIN_PATH` diatur dengan benar selama sesi terminal baru. Pada perangkat Raspberry Pi, skrip start-up shell adalah. `~/.bashrc`
Jalankan perintah berikut untuk menambahkan perintah ke akhir skrip start-up shell.
```
echo "export GST_PLUGIN_PATH=~/Downloads/kvs-producer-sdk-cpp/build" >> ~/.bashrc
```
Ketik berikut ini untuk menjalankan skrip start-up shell, atau tutup shell saat ini dan buka yang baru.
```
source ~/.bashrc
```
Konfirmasikan `GST_PLUGIN_PATH` sudah diatur dan Anda dapat memuat`kvssink`.
```
echo $GST_PLUGIN_PATH
```
```
gst-inspect-1.0 kvssink
```
# Streaming video ke aliran video Kinesis Anda
Untuk menjalankan aplikasi sampel, Anda memerlukan informasi berikut:
+ Nama aliran yang Anda buat di [Prasyarat](producersdk-cpp-rpi-prerequisites.md) bagian ini.
+ Kredensyal akun (ID kunci akses dan kunci akses rahasia) yang Anda buat. [Buat pengguna IAM dengan izin untuk menulis ke Kinesis Video Streams](producersdk-cpp-rpi-iam.md)
+ GStreamer dapat menemukan `kvssink` plugin. Untuk informasi selengkapnya, lihat [Unduh dan buat SDK produser Kinesis Video Streams C \$1\$1](producersdk-cpp-rpi-download.md).
1. Atur kredensil dan wilayah.
```
export AWS_ACCESS_KEY_ID=YourAccessKey
export AWS_SECRET_ACCESS_KEY=YourSecretKey
export AWS_DEFAULT_REGION=us-west-2
```
Untuk metode otentikasi lainnya, lihat[Memberikan kredensi untuk `kvssink`](examples-gstreamer-plugin-parameters.md#credentials-to-kvssink).
**catatan**
SDK produsen C \$1\$1 menggunakan Wilayah AS Barat (Oregon) (`us-west-2`) secara default. Untuk menggunakan default, Wilayah AWS buat aliran video Kinesis Anda di Wilayah AS Barat (Oregon).
Untuk menggunakan Wilayah yang berbeda untuk aliran video Kinesis Anda, setel variabel lingkungan berikut ke Wilayah Anda (misalnya,*us-east-1*):
```
export AWS_DEFAULT_REGION=us-east-1
```
1. Tergantung pada media masukan Anda, pilih salah satu dari yang berikut ini:
------
#### [ Sample GStreamer video ]
GStreamer Pipeline ini menghasilkan streaming video uji langsung dengan pola pengujian standar yang berjalan pada 10 frame per detik dengan resolusi 640x480 piksel. Hamparan ditambahkan menampilkan waktu dan tanggal sistem saat ini. Video kemudian dikodekan ke dalam format H.264 dan keyframe dihasilkan paling banyak setiap 10 frame, menghasilkan durasi fragmen (juga dikenal sebagai ukuran grup gambar (GoP)) 1 detik. kvssink mengambil aliran video yang dikodekan H.264, mengemasnya ke dalam format wadah Matroska (MKV), dan mengunggahnya ke aliran video Kinesis Anda.
Jalankan perintah berikut:
```
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"
```
Untuk menghentikan GStreamer pipa, pilih jendela terminal dan tekan **CTRL\$1C**.
Contoh GStreamer pipa video terlihat seperti ini:
![\[Gambar pola uji standar dengan stempel tanggal dan waktu yang dilapis.\]](http://docs.aws.amazon.com/id_id/kinesisvideostreams/latest/dg/images/sample-video.png)
------
#### [ USB web cam ]
Jalankan perintah berikut untuk GStreamer mendeteksi kamera USB Anda secara otomatis:
```
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"
```
Untuk menghentikan GStreamer pipa, pilih jendela terminal dan tekan **CTRL\$1C**.
Daripada membiarkan GStreamer deteksi otomatis, Anda dapat menggunakan `v4l2src` dengan pengenal perangkat tertentu. Jalankan perintah berikut:
```
gst-device-monitor-1.0
```
Dalam output, Anda akan melihat beberapa perangkat dan awal GStreamer pipeline untuk cara menggunakan perangkat:
```
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 ! ...
```
Untuk menghentikan GStreamer pipa, pilih jendela terminal dan tekan **CTRL\$1C**.
------
#### [ Raspberry Pi camera module 1 ]
Jika Anda menggunakan modul kamera Pi 1 atau modul kamera Pi 2 dengan`bcm2835-v4l2`, gunakan yang berikut ini:
```
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"
```
Untuk menghentikan GStreamer pipa, pilih jendela terminal dan tekan **CTRL\$1C**.
------
#### [ Raspberry Pi camera module 2 or 3 ]
Jika Anda menggunakan `libcamera` tumpukan modern, gunakan GStreamer pipeline berikut:
```
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"
```
Untuk menghentikan GStreamer pipa, pilih jendela terminal dan tekan **CTRL\$1C**.
------
#### [ Sample RTSP camera ]
Untuk contoh ini, kami gunakan Gst-Rtsp-Server untuk meng-host umpan kamera demo RTSP secara lokal. Kami kemudian membuat GStreamer pipeline untuk mengunggah umpan kamera RTSP ke aliran video Kinesis yang ditentukan.
**Untuk mengatur Gst-Rtsp-Server Raspberry Pi Anda**
1. Instal perpustakaan ketergantungan yang diperlukan untuk membangun proyek. Gst-Rtsp-Server Pastikan Anda memiliki prasyarat perangkat lunak yang diinstal juga. Ketik berikut ini ke terminal Anda:
```
sudo apt-get update
sudo apt-get install libgstrtspserver-1.0
```
1. Unduh versi 1.22 GStreamer di Raspberry Pi Anda.
```
git clone https://gitlab.freedesktop.org/gstreamer/gstreamer.git --single-branch -b 1.22
```
1. Ubah direktori ke direktori examples di file. gst-rtsp-server
```
cd gstreamer
cd subprojects
cd gst-rtsp-server
cd examples
```
1. Kompilasi test-launch.c menjadi executable yang disebut test-launch menggunakan gcc.
```
gcc -o test-launch test-launch.c `pkg-config --cflags --libs gstreamer-rtsp-server-1.0`
```
1. Jalankan executable dengan argumen berikut. Catatan: GStreamer mungkin perlu waktu untuk memuat untuk pertama kalinya.
```
./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"
```
Anda akan melihat output berikut:
```
stream ready at rtsp://127.0.0.1:8554/test
```
1. Verifikasi aliran video RTSP. Anda dapat menggunakan penampil RTSP apa pun. Misalnya, pemutar media VLC. Untuk menggunakan pemutar media VLC untuk melihat streaming langsung Anda, buka terminal baru dan ketik:
```
sudo apt-get install vlc
```
untuk menginstal pemutar media VLC. Lalu ketik:
```
vlc rtsp://127.0.0.1:8554/test
```
Jendela VLC akan muncul dengan streaming langsung. Jika tidak, periksa apakah executable tes-launch masih berjalan dan periksa output untuk kesalahan apa pun.
Cara lain untuk memverifikasi aliran RTSP adalah dengan menggunakan utilitas gst-discoverer-1.0. Jenis:
```
gst-discoverer-1.0 "rtsp://127.0.0.1:8554/test"
```
Output yang diharapkan terlihat seperti ini:
```
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
```
**Untuk mengirim umpan RTSP ke Kinesis Video Stream Anda menggunakan kvssink**
GStreamer Pipeline ini digunakan `rtspsrc` untuk terhubung ke server RTSP untuk mengambil aliran video RTP. Ini melewati bingkai ke`rtph264depay`, yang mengekstrak bingkai video yang dikodekan H.264 dari paket RTP. `h264parse`kelompok frame video ke dalam format `kvssink` dapat memahami. `kvssink`mengambil aliran video yang dikodekan H.264, mengemasnya ke dalam format wadah Matroska (MKV), dan mengunggahnya ke aliran video Kinesis Anda.
Jalankan perintah berikut:
```
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"
```
Untuk menghentikan GStreamer pipa, pilih jendela terminal dan tekan **CTRL\$1C**.
------
## Memanfaatkan perangkat keras
Beberapa model Raspberry Pi hadir dengan encoder H.264 yang dipercepat perangkat keras. Anda dapat menggunakannya sebagai pengganti`x264enc`, yang merupakan encoder perangkat lunak.
1. Pastikan bahwa GStreamer plugin diinstal:
```
sudo apt-get install gstreamer1.0-tools gstreamer1.0-plugins-bad
```
1. Jenis:
```
gst-inspect-1.0 | grep h264
```
Tentukan apakah elemen-elemen berikut tersedia:
+ omxh264enc
+ v4l2h264enc
Jika tersedia, Anda dapat menggunakannya. Berikut adalah beberapa contoh pipeline menggunakan elemen-elemen tersebut:
**`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`dan`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"
```
## Masalah runtime
Berikut ini adalah beberapa masalah runtime yang sering ditemui, dan cara memecahkan masalah mereka.
### Tidak ada elemen seperti “xxxxxxxxx”
Jika Anda menerima kesalahan seperti berikut ini, itu berarti Anda kehilangan GStreamer plugin:
```
WARNING: erroneous pipeline: no element "videoconvert"
```
**Resolusi:**
Berdasarkan elemen mana yang hilang, tentukan tindakan yang sesuai:
+ `kvssink`: Lihat[Unduh dan buat SDK produser Kinesis Video Streams C \$1\$1](producersdk-cpp-rpi-download.md).
+ `libcamerasrc`: Lihat [Kesalahan “Aktivasi kumpulan buffer gagal”](#rpi-troubleshoot-buffer) untuk menginstal `libcamerasrc` GStreamer elemen.
+ `omxh264enc` atau `v4l2h264enc`:
Ikuti [Instal prasyarat perangkat lunak](producersdk-cpp-rpi-software.md) untuk menginstal semua GStreamer perpustakaan. Jika Anda telah menginstal semuanya dan elemen-elemen ini tidak muncul, itu berarti Raspberry Pi Anda tidak memiliki perangkat keras. Gunakan encoder `x264enc` perangkat lunak sebagai gantinya.
+ Lainnya: Ikuti [Instal prasyarat perangkat lunak](producersdk-cpp-rpi-software.md) untuk menginstal semua GStreamer pustaka. GStreamer Elemen yang berbeda ditemukan di berbagai grup GStreamer plugin (baik, buruk, jelek), jadi pastikan untuk menginstal semuanya.
### Kesalahan “Aktivasi kumpulan buffer gagal”
Jika Anda menerima kesalahan seperti berikut ini berarti pipeline yang digunakan digunakan`v4l2src`, tetapi seharusnya digunakan `libcamerasrc` sebagai gantinya.
```
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)
```
Misalnya, jika Anda menggunakan pipeline berikut dengan modul kamera 2 tanpa `libcamerasrc` diinstal, Anda mungkin mengalami kesalahan ini saat GStreamer mencoba mendeteksi elemen mana yang akan digunakan secara otomatis.
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
**Resolusi:**
Pastikan `libcamerasrc` yang diinstal dan menggunakannya sebagai elemen sumber, bukan`v4l2src`. Ketik berikut ini untuk menginstal `libcamerasrc` GStreamer elemen:
```
sudo apt-get update
sudo apt-get install gstreamer1.0-libcamera
```
Setelah `libcamerasrc` diinstal, jika Anda menggunakan `autovideosrc` elemen, GStreamer harus secara otomatis beralih untuk menggunakan sumber yang benar `libcamerasrc` alih-alih`v4l2src`.
### Kesalahan bus
Jika Anda menerima kesalahan Bus segera setelah memulai `kvssink` (biasanya, sekitar waktu panggilan HTTP untuk `PutMedia` selesai), itu berarti Raspberry Pi Anda tidak mendukung akses memori yang tidak selaras. Log akan terlihat seperti berikut:
```
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 menggunakan akses memori yang tidak selaras untuk mengoptimalkan penggunaan memori, yang tidak didukung oleh semua perangkat.
**Resolusi:**
Untuk menggunakan SDK dalam mode akses memori yang selaras, Anda perlu secara eksplisit menyetel `ALIGNED_MEMORY_MODEL` CMake flag `ON` saat mengkompilasi`kvssink`, karena default ke. `OFF` Lihat [Unduh dan buat SDK produser Kinesis Video Streams C \$1\$1](producersdk-cpp-rpi-download.md) untuk instruksi lebih rinci.
### Stempel waktu membeku dan pipa berhenti
Saat menggunakan `x264enc` dalam GStreamer pipa, Anda mungkin menghadapi situasi di mana garis waktu pipa melambat secara signifikan atau benar-benar berhenti dalam beberapa detik.
Ini terjadi karena pengaturan `x264enc` default dapat memperkenalkan latensi pengkodean tinggi, yang melebihi kapasitas buffer input default. Akibatnya, buffer input terisi, menyebabkan elemen hulu terblokir dan pipa macet.
Lihat informasi yang lebih lengkap dalam [dokumentasi GStreamer ](https://gstreamer.freedesktop.org/documentation/x264/index.html?gi-language=c).
**Resolusi:**
Konfigurasikan `x264enc` dengan opsi `zerolatency` penyetelan. Ini secara signifikan mengurangi latensi pengkodean dengan mengoptimalkan skenario waktu nyata, memastikan frame diproses dan dikeluarkan lebih cepat.
Contoh konfigurasi:
```
... ! x264enc tune=zerolatency byte-stream=true speed-preset=ultrafast bframes=0 key-int-max=60 ! ...
```
**catatan**
Meskipun solusi ini secara efektif mencegah penghentian pipa, ini dapat memengaruhi efisiensi dan kualitas pengkodean. Untuk skenario yang membutuhkan latensi rendah dan kualitas tinggi, pertimbangkan pendekatan alternatif, seperti menggunakan pengoptimalan perangkat keras atau menemukan kamera web yang menghasilkan H.264 secara langsung, lewati langkah pengkodean ini.
Untuk informasi selengkapnya, lihat [Memanfaatkan perangkat keras](#producersdk-cpp-rpi-utilize).
### Tidak dapat menjalankan beberapa pipeline dari `v4l2` perangkat yang sama secara bersamaan
Perangkat seperti hanya `/dev/video0` dapat diakses oleh satu proses pada satu waktu. Jika beberapa proses mencoba mengaksesnya pada saat yang sama, yang kedua menunggu sampai yang pertama selesai.
**Resolusi:**
Buat perangkat loopback, memungkinkan beberapa proses untuk menggunakan antarmuka loopback secara bersamaan. Untuk informasi selengkapnya, lihat [Stack Exchange](https://raspberrypi.stackexchange.com/questions/19630/take-picam-image-while-motion-is-running/19897#19897).
### Kesalahan aliran data internal
Saat Anda membuat GStreamer pipa, Anda menghubungkan elemen dengan menautkan pad sumber dari satu elemen ke bantalan wastafel elemen lain. Proses penautan ini memungkinkan aliran data dari elemen sumber ke elemen sink, membentuk pipa data.
Pesan kesalahan “Tautan pad gagal” di log menunjukkan bahwa GStreamer mengalami masalah saat mencoba membuat koneksi (tautan) antara bantalan dua elemen di pipeline Anda.
```
Pad link failed
Error received from element udpsrc0: Internal data stream error.
```
**Resolusi:**
Tentukan elemen mana yang gagal terhubung satu sama lain. Untuk mempersempit ruang lingkup pipa, hapus elemen dari pipa. Ganti elemen paling kanan dengan `fakesink` dan hapus elemen satu per satu.
Anda mungkin perlu menyesuaikan elemen [capsfilter](https://gstreamer.freedesktop.org/documentation/coreelements/capsfilter.html?gi-language=c), and/or mengubah elemen mana yang digunakan pipeline Anda.
Kasus umum meminta `framerate` atau `resolution` kamera tidak mendukung. Gunakan `gst-device-monitor-1.0` di terminal untuk mendapatkan dukungan`framerates`,`resolutions`, dan`formats`. Anda dapat menggunakan GStreamer elemen [skala video](https://gstreamer.freedesktop.org/documentation/videoconvertscale/videoscale.html?gi-language=c) untuk menyesuaikan resolusi video, dan [videorate](https://gstreamer.freedesktop.org/documentation/videorate/?gi-language=c) untuk menyesuaikan kecepatan bingkai video.
Untuk memeriksa format yang didukung untuk GStreamer elemen individual, `gst-inspect-1.0 element-name` ketik terminal.
# Putar kembali media dari aliran video Kinesis Anda
Buka konsol [Kinesis Video](https://console.aws.amazon.com//kinesisvideo/home/) Streams dan **pilih nama Stream untuk streaming yang** Anda buat.
Aliran video yang dikirim dari Raspberry Pi muncul di konsol.
**catatan**
Mungkin perlu beberapa detik sebelum video muncul di konsol.
Setelah streaming diputar, Anda dapat bereksperimen dengan fitur-fitur berikut di konsol:
+ Di bagian **Pratinjau video**, gunakan kontrol navigasi untuk memundurkan atau mempercepat aliran.
+ Di bagian **Stream info**, tinjau codec, resolusi, dan bit rate aliran. Resolusi dan nilai bit rate diatur dengan sengaja rendah pada Raspberry Pi untuk meminimalkan penggunaan bandwidth untuk tutorial ini.
Untuk melihat CloudWatch metrik Amazon yang sedang dibuat untuk streaming Anda, pilih **Lihat metrik aliran** di. CloudWatch
+ Di bawah **periode penyimpanan data**, perhatikan bahwa aliran video dipertahankan selama satu hari. Anda dapat mengedit nilai ini dan mengaturnya ke **Tidak ada retensi data**, atau menetapkan nilai dari satu hari hingga beberapa tahun.
+ Di bawah **enkripsi sisi server**, perhatikan bahwa data Anda sedang dienkripsi saat istirahat menggunakan kunci yang dikelola oleh (). AWS Key Management Service AWS KMS
## Masalah pemutaran
Berikut ini adalah beberapa masalah pemutaran yang sering ditemui, dan cara memecahkan masalah mereka.
### Tidak ada media, tetapi ada ACK PERSISTED di log
Jika Anda melihat Ack PERSISTED di log, Kinesis Video Streams telah berhasil menyerap dan menyimpan media yang diunggah oleh. `kvssink` Ack yang diterima dari Kinesis Video Streams terlihat seperti ini. Di JSON, lihat nilai untuk `"EventType"` kuncinya.
```
{"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"}
```
**Resolusi:**
Tunggu satu atau dua menit di konsol Kinesis Video Streams, lalu gunakan panah kanan ganda. Jika tidak ada media yang muncul, verifikasi bahwa aliran Anda dikirim ke wilayah yang benar dan tinjau ejaan nama aliran. Anda dapat menemukan informasi ini di log.
Lihat [Menyediakan wilayah untuk `kvssink`](examples-gstreamer-plugin-parameters.md#kvssink-region) untuk informasi lebih lanjut tentang bagaimana kvssink menentukan wilayah mana yang akan digunakan.
### Media membutuhkan waktu lama untuk memuat di Konsol Manajemen AWS
**penting**
Pengalaman pemutaran konsol berbeda dari pengalaman pemutaran HLS dan DASH. Gunakan [halaman web yang dihosting](https://aws-samples.github.io/amazon-kinesis-video-streams-media-viewer/) pemutar media sampel GitHub untuk menguji pemutaran juga. Kode sumber untuk halaman web dapat ditemukan [di sini](https://github.com/aws-samples/amazon-kinesis-video-streams-media-viewer).
Media dapat memuat secara perlahan di konsol karena bandwidth jaringan yang buruk atau perangkat yang dibatasi, tetapi juga dapat dikaitkan dengan pengkodean dan fragmentasi video.
**Dasar-dasar Pengkodean Video:**
+ Encoder H.264 dan H.265 menggunakan key-frame (I-Frames) dan predicted-frame (P-Frames) untuk kompresi yang efisien.
+ Key-frame berisi data gambar lengkap, sedangkan P-frame hanya berisi perubahan dari frame sebelumnya.
+ “Interval bingkai kunci” menentukan seberapa sering bingkai kunci terjadi dalam aliran video.
**Fragmentasi dalam Streaming:**
+ Di Kinesis Video Streams, fragmen baru dimulai dengan setiap bingkai kunci. Untuk informasi selengkapnya, lihat [Model data Kinesis Video Streams](how-data.md).
+ *Panjang fragmen (dalam detik) dapat diperkirakan sebagai: *interval bingkai kunci ÷ frame rate**
**Contoh:**
Untuk streaming dengan interval kunci-frame 30 dan frame rate 15 fps:
Panjang Fragmen = 30 ÷ 15 = 2 detik
Karena interval bingkai kunci yang lebih besar, fragmen yang lebih lama meningkatkan latensi di media streaming.
**Resolusi:**
Untuk meningkatkan waktu pemuatan, pertimbangkan untuk mengurangi interval bingkai kunci. Ini akan membuat fragmen yang lebih pendek, mengurangi latensi, tetapi juga akan meningkatkan ukuran file video.
Untuk `x264enc` GStreamer elemen, Anda dapat secara eksplisit mengatur interval kunci-bingkai melalui properti: `key-int-max`
```
x264enc bframes=0 key-int-max=60
```
Saat meninjau keluaran log, perhatikan seberapa sering klien yang mengunggah menerima ACKs dari Kinesis Video Streams. Semakin banyak keyframe yang dihasilkan, semakin banyak ACKs yang dikembalikan.
### Media terdistorsi atau memiliki artefak
Untuk mengatasi masalah ini, pastikan semua kabel terhubung erat. Tinjau output `libcamera-hello` (atau `raspistill` untuk kamera Pi lama) untuk modul kamera.
Dalam GStreamer pipa Anda, ganti `kvssink` dengan `autovideosink` atau `matroskamux` dan`filesink`. Contoh:
```
... x264enc tune=zerolatency speed-preset=ultrafast bframes=0 key-int-max=60 byte-stream=true ! h264parse ! matroskamux ! filesink location=output.mkv
```
Tinjau file output untuk `filesink` atau pemutar media yang terbuka saat menggunakan `autovideosink` untuk melihat apakah artefak juga ada di sana.
Juga tinjau output dari pipa berikut:
```
gst-launch-1.0 autovideosrc ! videoconvert ! autovideosink
```
Menambahkan elemen ke pipeline Anda, seperti [dewarp](https://gstreamer.freedesktop.org/documentation/opencv/dewarp.html?gi-language=c), dapat memperbaiki output kamera mata ikan.
Tinjau codec keluaran yang didukung untuk kamera Anda dan sesuaikan elemen sesuai kebutuhan.
Misalnya, jika kamera USB Anda hanya mendukung output JPEG, maka Anda perlu menggunakan `jpegdec` elemen `jpegparse` dan untuk mengubah media sebelum menyandikannya menjadi H.264 menggunakan. `x264enc` Cari bantuan di GStreamer forum untuk pengguna lain dengan pipeline serupa dan/atau pengaturan web cam.
# Memecahkan masalah build pada SDK produsen C \$1\$1 untuk Raspberry Pi
Jika Anda mengalami masalah build dan ingin mencoba CMake argumen yang berbeda, pastikan untuk melakukan build yang bersih. Hapus folder `open-source``dependency`, dan `build` folder sebelum Anda mencoba lagi.
## Membangun masalah dengan OpenSSL
Jika Anda menerima output yang mirip dengan berikut ini, ini menunjukkan bahwa OpenSSL telah salah mendeteksi arsitektur sistem Anda.
```
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]'
```
Dalam contoh ini, ia mencoba untuk membangun versi 64-bit (`linux-aarch64`) ketika Raspberry Pi ini sebenarnya 32-bit. Beberapa perangkat Raspberry Pi memiliki kernel 64-bit, tetapi ruang pengguna 32-bit.
Tentukan arsitektur OpenSSL yang coba dibangun oleh OpenSSL. Anda dapat menemukan baris log selama `configure` langkah untuk 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
```
Verifikasi arsitektur sistem Anda:
+ Tinjau kernel bit-ness: jalankan `uname -m`
+ Tinjau bit-ness ruang pengguna: jalankan `getconf LONG_BIT`
Anda juga dapat meninjau informasi CPU Anda dengan `cat /proc/cpuinfo` atau `lscpu` perintah.
**Resolusi:**
Untuk mengatasi masalah ini, tambahkan CMake argumen berikut saat membuat, untuk memastikan OpenSSL dibangun dengan benar untuk arsitektur ARM 32-bit:
```
-DBUILD_OPENSSL_PLATFORM=linux-armv4
```
## Memecahkan masalah `kvssink` pemuatan di GStreamer
Konfirmasikan `GST_PLUGIN_PATH`
Pastikan variabel `GST_PLUGIN_PATH` lingkungan dalam sesi shell Anda saat ini menunjuk ke direktori yang berisi`kvssink`. Variabel lingkungan khusus untuk sesi, jadi Anda harus mengaturnya untuk setiap sesi baru. Untuk membuat perubahan ini permanen, lihat “Perbarui skrip start-up shell Anda untuk menyertakan pengaturan variabel lingkungan GST\$1PLUGIN\$1PATH”.
**Kesalahan: Tidak dapat membuka file objek bersama: Tidak ada file atau direktori seperti itu**
Jika Anda mengalami kesalahan`Cannot open shared object file: No such file or directory`, jalankan perintah berikut:
```
gst-inspect-1.0 /path/to/libgstkvssink.so
```
Jika Anda menerima output berikut, ini menunjukkan bahwa penaut dinamis tidak dapat menemukan pustaka yang diperlukan untuk. `kvssink` Ini biasanya terjadi karena:
+ Pindah `kvssink` ke lokasi yang berbeda dari tempat ia dibangun.
+ Kompilasi silang untuk arsitektur CPU yang salah.
+ Ketergantungan yang diperlukan tidak ada.
**Output:**
```
WARNING: erroneous pipeline: no element "kvssink"
error while loading shared libraries: libcproducer.so: cannot open shared object file: No such file or directory
```
**Resolusi:**
Untuk **pustaka yang dipindahkan**, tambahkan direktori yang berisi pustaka yang hilang ke. `LD_LIBRARY_PATH`
Dari direktori root repositori asli, Anda dapat menemukan perpustakaan yang hilang menggunakan utilitas`find`. Di terminal, ketik:
```
find . -name "*libcproducer*"
```
**Output:**
```
./build/dependency/libkvscproducer/kvscproducer-src/libcproducer.so
```
Pemisah jalur file pada perangkat Linux adalah`:`. Perintah di bawah ini menambahkan path folder baru ke variabel `LD_LIBRARY_PATH` lingkungan yang ada, melestarikan nilai sebelumnya.
Di terminal Anda, ketik:
```
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/build/dependency/libkvscproducer/kvscproducer-src
```
**penting**
Variabel lingkungan bersifat spesifik untuk sesi. Untuk mempertahankan perubahan di seluruh sesi, ubah skrip startup shell Anda.
Anda mungkin juga perlu menambahkan `open-source/local/lib` ke Anda`$LD_LIBRARY_PATH`.
**Kesalahan:. /path/to/libcproducer.so.1:** header ELF tidak valid
Jika Anda menerima kesalahan ini saat memuat **pustaka bersama**, itu mungkin karena tautan simbolik yang rusak (). `symlinks` Symlink dapat rusak jika sistem operasi mesin host tidak cocok dengan mesin target. Misalnya, kompilasi silang pada a MacBook untuk Raspberry Pi.
Penyebab lain yang mungkin adalah bahwa binari yang dibangun adalah untuk arsitektur yang salah. Misalnya, jika binari dibangun untuk x86 (Raspberry Pi menggunakan ARM CPUs).
Arahkan ke lokasi pustaka yang ditentukan dalam kesalahan dan ketik: `ls -la` untuk memeriksa pustaka`symlinks`.
**Tanggapan:**
```
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
```
Pada output sampel di atas, `symlinks` tidak rusak. Rusak `symlinks` tidak akan memiliki panah yang menunjuk ke target mereka.
**Resolusi:**
Ada dua opsi untuk memperbaiki symlink:
+ **Direkomendasikan:** Buat ulang `symlink` dengan `ln` perintah. Jenis:
```
ln -s /path/to/actual/library /path/to/symlink
```
+ Salin file pustaka yang sebenarnya dan ganti namanya agar sesuai dengan file. `symlink`
**catatan**
Opsi ini mengarah pada peningkatan penggunaan penyimpanan.
Sebagai praktik terbaik, kompilasi pada sistem operasi yang sama menggunakan alat seperti Docker untuk menghindari masalah kompilasi silang.
**Dependensi yang hilang:**
Jika nama pustaka yang hilang dimulai`libkvs`, lihat bagian untuk “pustaka yang dipindahkan” di atas untuk menginstal pustaka Kinesis Video Streams dari perangkat host ke perangkat target.
Jika tidak, ikuti [Instal prasyarat perangkat lunak](producersdk-cpp-rpi-software.md) untuk memastikan semua prasyarat perangkat lunak sumber terbuka diinstal pada perangkat target.