Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Gunakan pustaka produser C
Anda dapat menggunakan Amazon Kinesis Video Streams yang disediakan perpustakaan produser C untuk menulis kode aplikasi untuk mengirim data media dari perangkat ke aliran video Kinesis.
## Model objek
[Pustaka produser Kinesis Video Streams C didasarkan pada komponen umum yang disebut Platform Independent Codebase (PIC), yang tersedia GitHub di -pic/. https://github.com/awslabs/ amazon-kinesis-video-streams](https://github.com/awslabs/amazon-kinesis-video-streams-pic/) PIC berisi logika bisnis platform-independen untuk komponen dasar. Pustaka produser Kinesis Video Streams C membungkus PIC dengan lapisan API tambahan yang memungkinkan panggilan balik dan peristiwa khusus skenario dan platform. Pustaka produser Kinesis Video Streams C memiliki komponen berikut yang dibangun di atas PIC:
+ **Penyedia info perangkat** — Mengekspos `DeviceInfo` struktur yang dapat langsung dipasok ke PIC API. Anda dapat mengonfigurasi serangkaian penyedia, termasuk penyedia yang dioptimalkan skenario aplikasi yang dapat mengoptimalkan penyimpanan konten berdasarkan jumlah dan jenis aliran yang ditangani aplikasi Anda dan jumlah buffering yang diperlukan yang dikonfigurasi berdasarkan jumlah RAM yang tersedia.
+ **Penyedia info aliran** — Mengekspos `StreamInfo` struktur yang dapat langsung dipasok ke PIC API. Ada satu set penyedia yang khusus untuk jenis aplikasi dan jenis skenario streaming yang umum. Ini termasuk penyedia seperti video, audio, dan audio dan video multitrack. Masing-masing skenario ini memiliki default yang dapat Anda sesuaikan sesuai dengan kebutuhan aplikasi Anda.
+ **Penyedia panggilan balik** - Mengekspos `ClientCallbacks` struktur yang dapat langsung dipasok ke PIC API. Ini termasuk satu set penyedia callback untuk jaringan (callback API berbasis Curl), otorisasi (API AWS kredensial), dan coba lagi streaming pada callback error. API Penyedia Panggilan Balik mengambil sejumlah argumen untuk dikonfigurasi, seperti informasi Wilayah AWS dan otorisasi. Ini dilakukan dengan menggunakan sertifikat IoT atau dengan menggunakan AWS AccessKeyId, SecretKey, atau. SessionToken Anda dapat menyempurnakan Penyedia Callback dengan callback khusus jika aplikasi Anda memerlukan pemrosesan lebih lanjut dari callback tertentu untuk mencapai beberapa logika khusus aplikasi.
+ **FrameOrderCoordinator**— Membantu menangani sinkronisasi audio dan video untuk skenario multi-track. Ini memiliki perilaku default, yang dapat Anda sesuaikan untuk menangani logika spesifik aplikasi Anda. Ini juga merampingkan kemasan metadata bingkai dalam struktur PIC Frame sebelum mengirimkannya ke PIC API lapisan bawah. Untuk skenario non-multitrack, komponen ini adalah pass-through ke PIC PutFrame API.
Pustaka C menyediakan objek berikut untuk mengelola pengiriman data ke aliran video Kinesis:
+ **KinesisVideoClient**— Berisi informasi tentang perangkat Anda dan mempertahankan callback untuk melaporkan peristiwa Kinesis Video Streams.
+ **KinesisVideoStream**— Merupakan informasi tentang parameter aliran video, seperti nama, periode retensi data, dan jenis konten media.
## Masukkan media ke dalam aliran
Anda dapat menggunakan pustaka C yang disediakan metode (misalnya,`PutKinesisVideoFrame`) untuk menempatkan data ke dalam `KinesisVideoStream` objek. Pustaka kemudian mengelola status internal data, yang dapat mencakup tugas-tugas berikut:
+ Melakukan otentikasi.
+ Menonton latensi jaringan. Jika latensi terlalu tinggi, perpustakaan mungkin memilih untuk menjatuhkan bingkai.
+ Melacak status streaming yang sedang berlangsung.
## Prosedur: Gunakan SDK produsen C
Prosedur ini menunjukkan cara menggunakan klien Kinesis Video Streams dan sumber media dalam aplikasi C untuk mengirim bingkai video berenkode H.264 ke aliran video Kinesis Anda.
Prosedur ini mencakup langkah-langkah berikut:
+ [Unduh kode pustaka produser C](producersdk-c-download.md)
+ [Tulis dan periksa kodenya](producersdk-c-write.md)
+ [Jalankan dan verifikasi kode](producersdk-c-test.md)
# Prasyarat
Sebelum Anda mengatur SDK produsen C, pastikan Anda memiliki prasyarat berikut:
+ **Kredensial** — Dalam kode contoh, Anda memberikan kredensi dengan menentukan profil yang Anda atur dalam file profil kredensial Anda. AWS Jika Anda belum melakukannya, pertama-tama siapkan profil kredensional Anda.
Untuk informasi selengkapnya, lihat [Menyiapkan AWS Kredensial dan Wilayah untuk Pengembangan](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).
+ **Integrasi penyimpanan sertifikat** — Pustaka produser Kinesis Video Streams harus membangun kepercayaan dengan layanan yang dipanggilnya. Hal ini dilakukan dengan memvalidasi otoritas sertifikat (CAs) di toko sertifikat publik. Pada model berbasis Linux, toko ini terletak di direktori/. `/etc/ssl`
Unduh sertifikat dari lokasi berikut ke toko sertifikat Anda:
[https://www.amazontrust.com/repository/SFSRootCAG2.pem](https://www.amazontrust.com/repository/SFSRootCAG2.pem)
+ Instal dependensi build berikut untuk macOS:
+ [Autoconf 2.69](http://www.gnu.org/software/autoconf/autoconf.html) (Lisensi GPLv3 \$1/ Autoconf: GNU GPL versi 3 atau yang lebih baru)
+ [CMake 3.7 atau 3.8](https://cmake.org/)
+ [Konfigurasi Pkg](https://www.freedesktop.org/wiki/Software/pkg-config/)
+ XCode (macOS) /dentang/gcc (xcode-pilih versi 2347)
+ Java Development Kit (JDK) (untuk kompilasi Java JNI)
+ [Lib-Pkg](https://github.com/freebsd/pkg/tree/master/libpkg)
+ Instal dependensi build berikut untuk Ubuntu:
+ Git: `sudo apt install git`
+ [CMake](http://kitware.com/cmake): `sudo apt install cmake`
+ G\$1\$1: `sudo apt install g++`
+ pkg-config: `sudo apt install pkg-config`
+ OpenJDK: `sudo apt install openjdk-8-jdk`
+ Mengatur variabel `JAVA_HOME` lingkungan: `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/`
# Unduh kode pustaka produser C
Di bagian ini, Anda mengunduh pustaka tingkat rendah. Untuk prasyarat dan detail lainnya tentang contoh ini, lihat. [Gunakan pustaka produser C \$1\$1](producer-sdk-cpp.md)
1. Buat direktori, lalu kloning kode sumber contoh dari GitHub repositori.
```
git clone --recursive https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git
```
**catatan**
Jika Anda melewatkan menjalankan git clone dengan`--recursive`, jalankan `git submodule update --init` di `amazon-kinesis-video-streams-producer-c/open-source` direktori. Anda juga harus menginstal pkg-config, CMake, dan lingkungan build.
Untuk informasi selengkapnya, lihat `README.md` di [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git).
1. Buka kode di lingkungan pengembangan terintegrasi (IDE) pilihan Anda (misalnya, [Eclipse](https://www.eclipse.org/)).
# Tulis dan periksa kodenya
Di bagian ini, Anda memeriksa kode aplikasi sampel `KvsVideoOnlyStreamingSample.c` di `samples` folder repo [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c) pada. GitHub Anda mengunduh kode ini di langkah sebelumnya. Contoh ini menunjukkan cara menggunakan pustaka produser C untuk mengirim bingkai video yang dikodekan H.264 di dalam folder ke aliran video Kinesis Anda. `samples/h264SampleFrames`
Aplikasi sampel ini memiliki tiga bagian:
+ Inisialisasi dan konfigurasi:
+ Menginisialisasi dan mengonfigurasi saluran media khusus platform.
+ Menginisialisasi dan mengonfigurasi KinesisVideoClient dan KinesisVideoStream untuk pipeline, menyetel panggilan balik, mengintegrasikan otentikasi khusus skenario, mengekstrak dan mengirimkan data pribadi codec, dan mendapatkan aliran ke status READY.
+ Loop utama:
+ Mendapatkan bingkai dari pipa media dengan stempel waktu dan bendera.
+ Mengirimkan bingkai ke. KinesisVideoStream
+ Pembongkaran:
+ Berhenti (sinkronisasi) KinesisVideoStream, membebaskan KinesisVideoStream, membebaskan KinesisVideoClient.
Contoh aplikasi ini menyelesaikan tugas-tugas berikut:
+ Panggil `createDefaultDeviceInfo` API untuk membuat `deviceInfo` objek yang berisi informasi tentang perangkat atau konfigurasi penyimpanan.
```
// default storage size is 128MB. Use setDeviceInfoStorageSize after create to change storage size.
CHK_STATUS(createDefaultDeviceInfo(&pDeviceInfo));
// adjust members of pDeviceInfo here if needed
pDeviceInfo->clientInfo.loggerLogLevel = LOG_LEVEL_DEBUG;
```
+ Panggil `createRealtimeVideoStreamInfoProvider` API untuk membuat `StreamInfo` objek.
```
CHK_STATUS(createRealtimeVideoStreamInfoProvider(streamName, DEFAULT_RETENTION_PERIOD, DEFAULT_BUFFER_DURATION, &pStreamInfo));
// adjust members of pStreamInfo here if needed
```
+ Panggil `createDefaultCallbacksProviderWithAwsCredentials` API untuk membuat penyedia callback default berdasarkan AWS kredenal statis.
```
CHK_STATUS(createDefaultCallbacksProviderWithAwsCredentials(accessKey,
secretKey,
sessionToken,
MAX_UINT64,
region,
cacertPath,
NULL,
NULL,
FALSE,
&pClientCallbacks));
```
+ Panggil `createKinesisVideoClient` API untuk membuat `KinesisVideoClient` objek yang berisi informasi tentang penyimpanan perangkat Anda dan mempertahankan callback untuk melaporkan peristiwa Kinesis Video Streams.
```
CHK_STATUS(createKinesisVideoClient(pDeviceInfo, pClientCallbacks, &clientHandle));
```
+ Panggil `createKinesisVideoStreamSync` API untuk membuat `KinesisVideoStream` objek.
```
CHK_STATUS(createKinesisVideoStreamSync(clientHandle, pStreamInfo, &streamHandle));
```
+ Siapkan bingkai sampel dan panggil `PutKinesisVideoFrame` API untuk mengirim bingkai itu ke `KinesisVideoStream` objek.
```
// setup sample frame
MEMSET(frameBuffer, 0x00, frameSize);
frame.frameData = frameBuffer;
frame.version = FRAME_CURRENT_VERSION;
frame.trackId = DEFAULT_VIDEO_TRACK_ID;
frame.duration = HUNDREDS_OF_NANOS_IN_A_SECOND / DEFAULT_FPS_VALUE;
frame.decodingTs = defaultGetTime(); // current time
frame.presentationTs = frame.decodingTs;
while(defaultGetTime() > streamStopTime) {
frame.index = frameIndex;
frame.flags = fileIndex % DEFAULT_KEY_FRAME_INTERVAL == 0 ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE;
frame.size = SIZEOF(frameBuffer);
CHK_STATUS(readFrameData(&frame, frameFilePath));
CHK_STATUS(putKinesisVideoFrame(streamHandle, &frame));
defaultThreadSleep(frame.duration);
frame.decodingTs += frame.duration;
frame.presentationTs = frame.decodingTs;
frameIndex++;
fileIndex++;
fileIndex = fileIndex % NUMBER_OF_FRAME_FILES;
}
```
+ Pembongkaran:
```
CHK_STATUS(stopKinesisVideoStreamSync(streamHandle));
CHK_STATUS(freeKinesisVideoStream(&streamHandle));
CHK_STATUS(freeKinesisVideoClient(&clientHandle));
```
# Jalankan dan verifikasi kode
Untuk menjalankan dan memverifikasi kode untuk[Gunakan pustaka produser C \$1\$1](producer-sdk-cpp.md), lakukan hal berikut:
1. Jalankan perintah berikut untuk membuat `build` direktori di [C SDK yang Anda unduh](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git), dan luncurkan `cmake` darinya:
```
mkdir -p amazon-kinesis-video-streams-producer-c/build;
cd amazon-kinesis-video-streams-producer-c/build;
cmake ..
```
Anda dapat meneruskan opsi berikut ke `cmake ..`
+ `-DBUILD_DEPENDENCIES`- apakah akan membangun perpustakaan tergantung dari sumber.
+ `-DBUILD_TEST=TRUE`- membangun unit dan tes integrasi. Mungkin berguna untuk mengonfirmasi dukungan untuk perangkat Anda.
`./tst/webrtc_client_test`
+ `-DCODE_COVERAGE`- Aktifkan pelaporan cakupan.
+ `-DCOMPILER_WARNINGS`- Aktifkan semua peringatan kompiler.
+ `-DADDRESS_SANITIZER`- Membangun dengan AddressSanitizer.
+ `-DMEMORY_SANITIZER`- Membangun dengan MemorySanitizer.
+ `-DTHREAD_SANITIZER`- Membangun dengan ThreadSanitizer.
+ `-DUNDEFINED_BEHAVIOR_SANITIZER`- Membangun dengan UndefinedBehaviorSanitizer.
+ `-DALIGNED_MEMORY_MODEL`- membangun untuk perangkat model memori yang disejajarkan saja. Default-nya adalah `OFF`.
1. Arahkan ke `build` direktori yang baru saja Anda buat dengan langkah sebelumnya, dan jalankan `make` untuk membangun WebRTC C SDK dan sampel yang disediakan.
```
make
```
1. Aplikasi sampel `kinesis_video_cproducer_video_only_sample` mengirimkan bingkai video yang disandikan h.264 di dalam folder ke Kinesis Video Streams. `samples/h264SampleFrames` Perintah berikut mengirimkan frame video dalam satu lingkaran selama sepuluh detik ke Kinesis Video Streams:
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10
```
Jika Anda ingin mengirim frame yang dikodekan H.264 dari folder lain (misalnya,`MyH264FramesFolder`), jalankan sampel dengan argumen berikut:
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10 MyH264FramesFolder
```
1. Untuk mengaktifkan log verbose, tentukan `HEAP_DEBUG` dan `LOG_STREAMING` C-defines dengan menghapus komentar baris yang sesuai di. `CMakeList.txt`
Anda dapat memantau kemajuan rangkaian pengujian dalam output debug di IDE Anda. Anda juga dapat memantau lalu lintas di streaming Anda dengan menonton metrik yang terkait dengan streaming Anda di CloudWatch konsol Amazon, seperti`PutMedia.IncomingBytes`.
**catatan**
Konsol tidak menampilkan data sebagai aliran video karena test harness hanya mengirimkan frame byte kosong.