Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tulis dan periksa kodenya
Di bagian ini[Gunakan pustaka produser C \+\+](producer-sdk-cpp.md), Anda memeriksa kode di C\+\+ test harness (`tst/ProducerTestFixture.h`dan file lainnya). Anda mengunduh kode ini di bagian sebelumnya.
Contoh **Platform Independent** C\+\+ menunjukkan pola pengkodean berikut:
+ Buat instance `KinesisVideoProducer` untuk mengakses Kinesis Video Streams.
+ Buat instans `KinesisVideoStream`. Ini membuat aliran video Kinesis di Anda Akun AWS jika aliran dengan nama yang sama belum ada.
+ Panggil `putFrame` `KinesisVideoStream` untuk setiap frame data, karena tersedia, untuk mengirimkannya ke aliran.
Bagian berikut memberikan informasi lebih lanjut tentang pola pengkodean ini.
## Buat sebuah instance dari KinesisVideoProducer
Anda membuat `KinesisVideoProducer` objek dengan memanggil `KinesisVideoProducer::createSync` metode. Contoh berikut membuat `KinesisVideoProducer` dalam `ProducerTestFixture.h` file:
```
kinesis_video_producer_ = KinesisVideoProducer::createSync(move(device_provider_),
move(client_callback_provider_),
move(stream_callback_provider_),
move(credential_provider_),
defaultRegion_);
```
`createSync`Metode ini mengambil parameter berikut:
+ `DeviceInfoProvider`Objek, yang mengembalikan `DeviceInfo` objek yang berisi informasi tentang perangkat atau konfigurasi penyimpanan.
**catatan**
Anda mengonfigurasi ukuran toko konten Anda menggunakan `deviceInfo.storageInfo.storageSize` parameter. Aliran konten Anda berbagi toko konten. Untuk menentukan kebutuhan ukuran penyimpanan Anda, kalikan ukuran bingkai rata-rata dengan jumlah frame yang disimpan untuk durasi maksimal untuk semua aliran. Kemudian kalikan dengan 1,2 untuk memperhitungkan defragmentasi. Misalnya, misalkan aplikasi Anda memiliki konfigurasi berikut:
Tiga aliran
Durasi maksimum 3 menit
Setiap aliran adalah 30 frame per detik (FPS)
Setiap frame berukuran 10.000 KB
Persyaratan penyimpanan konten untuk aplikasi ini adalah **3 (aliran) \* 3 (menit) \* 60 (detik dalam satu menit) \* 10000 (kb) \* 1.2 (tunjangan defragmentasi) = 194,4** Mb \~ 200 Mb.
+ `ClientCallbackProvider`Objek, yang mengembalikan pointer fungsi yang melaporkan peristiwa khusus klien.
+ Sebuah `StreamCallbackProvider` objek, yang mengembalikan pointer fungsi yang dipanggil kembali ketika peristiwa khusus aliran terjadi.
+ Sebuah `CredentialProvider` objek, yang menyediakan akses ke variabel lingkungan AWS kredensi.
+ Wilayah AWS (“us-barat-2"). Titik akhir layanan ditentukan dari Wilayah.
## Buat sebuah instance dari KinesisVideoStream
Anda membuat `KinesisVideoStream` objek dengan memanggil `KinesisVideoProducer::CreateStream` metode dengan `StreamDefinition` parameter. Contoh membuat `ProducerTestFixture.h` file `KinesisVideoStream` dalam dengan jenis trek sebagai video, dan dengan track id sebagai 1:
```
auto stream_definition = make_unique(stream_name,
hours(2),
tags,
"",
STREAMING_TYPE_REALTIME,
"video/h264",
milliseconds::zero(),
seconds(2),
milliseconds(1),
true,
true,
true);
return kinesis_video_producer_->createStream(move(stream_definition));
```
`StreamDefinition`Objek memiliki bidang berikut:
+ Nama aliran.
+ Periode retensi data.
+ Tag untuk aliran. Tag ini dapat digunakan oleh aplikasi konsumen untuk menemukan aliran yang benar, atau untuk mendapatkan informasi lebih lanjut tentang aliran. Tag juga dapat dilihat di Konsol Manajemen AWS.
+ AWS KMS kunci enkripsi untuk aliran. Untuk informasi selengkapnya, lihat [Perlindungan data di Kinesis Video Streams](how-kms.md).
+ Jenis streaming. Saat ini, satu-satunya nilai yang valid adalah`STREAMING_TYPE_REALTIME`.
+ Jenis konten media.
+ Latensi media. Nilai ini saat ini tidak digunakan, dan harus disetel ke 0.
+ Durasi pemutaran setiap fragmen.
+ Skala kode waktu media.
+ Apakah media menggunakan fragmentasi bingkai kunci.
+ Apakah media menggunakan kode waktu.
+ Apakah media menggunakan waktu fragmen absolut.
## Tambahkan trek audio ke aliran video Kinesis
Anda dapat menambahkan detail trek audio ke definisi aliran trek video dengan menggunakan `addTrack` metode`StreamDefinition`:
```
stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO);
```
`addTrack`Metode ini membutuhkan parameter berikut:
+ Track id (sebagai satu untuk audio). Ini harus unik dan nilai bukan nol.
+ Nama trek yang ditentukan pengguna (misalnya, “audio” untuk trek audio).
+ Codec id untuk trek ini (misalnya, untuk trek audio “A\_AAC”).
+ Jenis trek (misalnya, gunakan nilai enum MKV\_TRACK\_INFO\_TYPE\_AUDIO untuk audio).
Jika Anda memiliki data pribadi codec untuk trek audio, maka Anda dapat meneruskannya saat memanggil fungsi addTrack. Anda juga dapat mengirim data pribadi codec setelah membuat KinesisVideoStream objek sambil memanggil metode awal di KinesisVideoStream.
## Masukkan bingkai ke dalam aliran video Kinesis
Anda menempatkan media ke dalam aliran video Kinesis menggunakan`KinesisVideoStream::putFrame`, meneruskan `Frame` objek yang berisi header dan data media. Contoh panggilan `putFrame` dalam `ProducerApiTest.cpp` file:
```
frame.duration = FRAME_DURATION_IN_MICROS * HUNDREDS_OF_NANOS_IN_A_MICROSECOND;
frame.size = SIZEOF(frameBuffer_);
frame.frameData = frameBuffer_;
MEMSET(frame.frameData, 0x55, frame.size);
while (!stop_producer_) {
// Produce frames
timestamp = std::chrono::duration_cast(
std::chrono::system_clock::now().time_since_epoch()).count() / DEFAULT_TIME_UNIT_IN_NANOS;
frame.index = index++;
frame.decodingTs = timestamp;
frame.presentationTs = timestamp;
// Key frame every 50th
frame.flags = (frame.index % 50 == 0) ? FRAME_FLAG_KEY_FRAME : FRAME_FLAG_NONE;
...
EXPECT_TRUE(kinesis_video_stream->putFrame(frame));
```
**catatan**
Contoh produsen C\+\+ sebelumnya mengirimkan buffer data uji. Dalam aplikasi dunia nyata, Anda harus mendapatkan buffer bingkai dan ukuran dari data bingkai dari sumber media (seperti kamera).
`Frame`Objek memiliki bidang berikut:
+ Indeks bingkai. Ini harus menjadi nilai yang meningkat secara monoton.
+ Bendera yang terkait dengan bingkai. Misalnya, jika encoder dikonfigurasi untuk menghasilkan bingkai kunci, bingkai ini akan diberi tanda. `FRAME_FLAG_KEY_FRAME`
+ Stempel waktu decoding.
+ Stempel waktu presentasi.
+ Durasi frame (untuk 100 ns unit).
+ Ukuran frame dalam byte.
+ Data bingkai.
Untuk informasi lebih lanjut tentang format bingkai, lihat[Model data Kinesis Video Streams](how-data.md).
## Masukkan KinesisVideoFrame ke dalam jalur tertentu dari KinesisVideoStream
Anda dapat menggunakan `PutFrameHelper` kelas untuk menempatkan data frame ke trek tertentu. Pertama, panggil `getFrameDataBuffer` untuk mendapatkan pointer ke salah satu buffer yang telah dialokasikan sebelumnya untuk mengisi data. `KinesisVideoFrame` Kemudian, Anda dapat memanggil `putFrameMultiTrack` untuk mengirim `KinesisVideoFrame` bersama dengan nilai Boolean untuk menunjukkan jenis data bingkai. Gunakan true jika itu adalah data video atau false jika frame berisi data audio. `putFrameMultiTrack`Metode ini menggunakan mekanisme antrian untuk memastikan bahwa Fragmen MKV mempertahankan stempel waktu bingkai yang meningkat secara monoton dan dua fragmen tidak tumpang tindih. Misalnya, stempel waktu MKV dari frame pertama fragmen harus selalu lebih besar dari stempel waktu MKV dari frame terakhir dari fragmen sebelumnya.
Ini `PutFrameHelper` memiliki bidang-bidang berikut:
+ Jumlah maksimum bingkai audio dalam antrian.
+ Jumlah maksimum bingkai video dalam antrian.
+ Ukuran untuk mengalokasikan untuk satu bingkai audio.
+ Ukuran untuk mengalokasikan untuk satu bingkai video.
## Akses metrik dan pencatatan metrik
SDK produsen C \+\+ mencakup fungsionalitas untuk metrik dan pencatatan metrik.
Anda dapat menggunakan operasi `getKinesisVideoMetrics` dan `getKinesisVideoStreamMetrics` API untuk mengambil informasi tentang Kinesis Video Streams dan aliran aktif Anda.
Kode berikut adalah dari `kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h` file.
```
/**
* Gets information about the storage availability.
*
* @param 1 CLIENT_HANDLE - the client object handle.
* @param 2 PKinesisVideoMetrics - OUT - Kinesis Video metrics to be filled.
*
* @return Status of the function call.
*/
PUBLIC_API STATUS getKinesisVideoMetrics(CLIENT_HANDLE, PKinesisVideoMetrics);
/**
* Gets information about the stream content view.
*
* @param 1 STREAM_HANDLE - the stream object handle.
* @param 2 PStreamMetrics - Stream metrics to fill.
*
* @return Status of the function call.
*/
PUBLIC_API STATUS getKinesisVideoStreamMetrics(STREAM_HANDLE, PStreamMetrics);
```
`PClientMetrics`Objek yang diisi oleh `getKinesisVideoMetrics` berisi informasi berikut:
+ **contentStoreSize:** Ukuran keseluruhan dalam byte penyimpanan konten (memori yang digunakan untuk menyimpan data streaming).
+ **contentStoreAvailableUkuran:** Memori yang tersedia di toko konten, dalam byte.
+ **contentStoreAllocatedUkuran:** Memori yang dialokasikan di toko konten.
+ **totalContentViewsUkuran:** Total memori yang digunakan untuk tampilan konten. Tampilan konten adalah serangkaian indeks informasi di toko konten.
+ **totalFrameRate:** Jumlah agregat frame per detik di semua aliran aktif.
+ **totalTransferRate:** Total bit per detik (bps) dikirim di semua aliran.
`PStreamMetrics`Objek yang diisi oleh `getKinesisVideoStreamMetrics` berisi informasi berikut:
+ **currentViewDuration:** Perbedaan unit 100 ns antara kepala tampilan konten (ketika frame dikodekan) dan posisi saat ini (ketika data frame dikirim ke Kinesis Video Streams).
+ **overallViewDuration:** Perbedaan unit 100 ns antara kepala tampilan konten (saat bingkai dikodekan) ke ekor (ketika bingkai dikeluarkan dari memori, baik karena total ruang yang dialokasikan untuk tampilan konten terlampaui, atau karena `PersistedAck` pesan diterima dari Kinesis Video Streams, dan bingkai yang diketahui bertahan dibilas).
+ **currentViewSize:** Ukuran dalam byte tampilan konten dari kepala (ketika frame dikodekan) ke posisi saat ini (ketika frame dikirim ke Kinesis Video Streams).
+ **overallViewSize:** Ukuran total dalam byte tampilan konten.
+ **currentFrameRate:** Laju aliran terukur terakhir, dalam bingkai per detik.
+ **currentTransferRate:** Laju aliran terukur terakhir, dalam byte per detik.
## Pembongkaran
Jika Anda ingin mengirim byte yang tersisa dalam buffer dan menunggu`ACK`, Anda dapat menggunakan: `stopSync`
```
kinesis_video_stream->stopSync();
```
Atau Anda dapat menelepon `stop` untuk mengakhiri streaming:
```
kinesis_video_stream->stop();
```
Setelah menghentikan streaming, Anda dapat membebaskan streaming dengan menjalankan API berikut:
```
kinesis_video_producer_->freeStream(kinesis_video_stream);
```