Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Schreiben und untersuchen Sie den Code
In diesem Abschnitt von untersuchen Sie den Code im C\+\+-Testcode (`tst/ProducerTestFixture.h`und anderen Dateien). [Verwenden Sie die C\+\+-Producer-Bibliothek](producer-sdk-cpp.md) Sie haben diesen Code im vorherigen Abschnitt heruntergeladen.
Das **plattformunabhängige** C\+\+-Beispiel zeigt das folgende Codierungsmuster:
+ Erstellen Sie eine Instanz von`KinesisVideoProducer`, um auf Kinesis Video Streams zuzugreifen.
+ Erstellen Sie eine Instance von `KinesisVideoStream`. Dadurch wird ein Kinesis-Videostream in Ihrem erstellt, AWS-Konto falls noch kein Stream mit demselben Namen vorhanden ist.
+ Rufen Sie `putFrame` im `KinesisVideoStream` für jeden Daten-Frame auf, sobald er verfügbar wird, um den Frame an den Stream zu senden.
In den folgenden Abschnitten finden Sie weitere Informationen zu diesem Codierungsmuster.
## Erstellen Sie eine Instanz von KinesisVideoProducer
Das `KinesisVideoProducer`-Objekt wird durch einen Aufruf der Methode `KinesisVideoProducer::createSync` erstellt. Im folgenden Beispiel wird `KinesisVideoProducer` in der Datei `ProducerTestFixture.h` erstellt:
```
kinesis_video_producer_ = KinesisVideoProducer::createSync(move(device_provider_),
move(client_callback_provider_),
move(stream_callback_provider_),
move(credential_provider_),
defaultRegion_);
```
Die Methode `createSync` verwendet die folgenden Parameter:
+ Ein `DeviceInfoProvider`-Objekt, das ein `DeviceInfo`-Objekt mit den Daten zu einem Gerät oder einer Speicherkonfiguration zurückgibt.
**Anmerkung**
Sie konfigurieren die Größe Ihres Inhaltsspeichers unter Verwendung des Parameters `deviceInfo.storageInfo.storageSize`. Ihre Inhalts-Streams verwenden denselben Inhaltsspeicher. Um Ihren Speicherbedarf zu ermitteln, multiplizieren Sie die durchschnittliche Frame-Größe mit der Anzahl der für die maximale Dauer aller Streams gespeicherten Frames. Multiplizieren Sie das Ergebnis dann mit 1,2, um die Defragmentierung zu berücksichtigen. Angenommen, Ihre Anwendung verwendet die folgende Konfiguration:
Drei Streams
3 Minuten maximale Dauer
Jeder Stream ist 30 Frames pro Sekunde (FPS)
Jeder Frame ist 10.000 KB groß
Die Inhaltsspeicheranforderung für diese Anwendung ist **3 (Streams) \* 3 (Minuten) \* 60 (Sekunden in einer Minute) \* 10000 (KB) \* 1,2 (Defragmentierungszuschuss) = 194,4 MB \~ 200 MB**.
+ Ein `ClientCallbackProvider`-Objekt, das Funktionszeiger zurückgibt, die Client-spezifische Ereignisse melden.
+ Ein `StreamCallbackProvider`-Objekt, das Funktionszeiger zurückgibt, die per Callback aufgerufen werden, wenn Stream-spezifische Ereignisse auftreten.
+ Ein `CredentialProvider` Objekt, das Zugriff auf Umgebungsvariablen mit AWS Anmeldeinformationen ermöglicht.
+ Die AWS-Region („us-west-2"). Der Service-Endpunkt wird anhand der Region bestimmt.
## Erstellen Sie eine Instanz von KinesisVideoStream
Sie erstellen das `KinesisVideoStream`-Objekt, indem Sie die Methode `KinesisVideoProducer::CreateStream` mit einem `StreamDefinition`-Parameter aufrufen. Das Beispiel erstellt den `KinesisVideoStream` in der Datei `ProducerTestFixture.h` mit dem Track-Typ als Video und der ID 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));
```
Das `StreamDefinition`-Objekt enthält folgende Felder:
+ Stream-Name.
+ Aufbewahrungszeitraum.
+ Tags für den Stream. Diese Tags können von Konsumentenanwendungen verwendet werden, um den richtigen Stream zu finden oder weitere Informationen über den Stream abzurufen. Die Tags können auch in der AWS-Managementkonsole angezeigt werden.
+ AWS KMS Verschlüsselungsschlüssel für den Stream. Weitere Informationen finden Sie unter [Datenschutz in Kinesis Video Streams](how-kms.md).
+ Streaming-Typ. Der einzige gültige Wert ist derzeit `STREAMING_TYPE_REALTIME`.
+ Medieninhaltstyp.
+ Medienlatenz. Dieser Wert wird derzeit nicht verwendet und sollte auf 0 gesetzt werden.
+ Wiedergabedauer jedes Fragments.
+ Medienzeitcode-Skala.
+ Gibt an, ob die Medien Keyframe-Fragmentierung verwenden.
+ Gibt an, ob die Medien Zeitcodes verwenden.
+ Gibt an, ob die Medien absolute Fragmentzeiten verwenden.
## Fügen Sie dem Kinesis-Videostream eine Audiospur hinzu
Sie können einer Videotrack-Stream-Definition Details zur Audiospur hinzufügen, indem Sie die `addTrack` folgende Methode verwenden`StreamDefinition`:
```
stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO);
```
Die `addTrack` Methode erfordert die folgenden Parameter:
+ Track-ID (wie eine für Audio). Dies sollte ein eindeutiger Wert ungleich Null sein.
+ Benutzerdefinierter Titelname (z. B. „Audio“ für den Audiotrack).
+ Codec-ID für diesen Titel (z. B. für den Audiotrack „A\_AAC“).
+ Spurtyp (verwenden Sie beispielsweise den Enum-Wert von MKV\_TRACK\_INFO\_TYPE\_AUDIO für Audio).
Wenn Sie private Codec-Daten für die Audiospur haben, können Sie sie beim Aufrufen der addTrack-Funktion übergeben. Sie können dem Codec auch private Daten senden, nachdem Sie das Objekt erstellt haben, während Sie die Startmethode in aufrufen. KinesisVideoStream KinesisVideoStream
## Fügen Sie einen Frame in den Kinesis-Videostream ein
Sie fügen Medien in den Kinesis-Videostream ein`KinesisVideoStream::putFrame`, indem Sie ein `Frame` Objekt übergeben, das den Header und die Mediendaten enthält. Das Beispiel ruft `putFrame` in der Datei `ProducerApiTest.cpp` auf:
```
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));
```
**Anmerkung**
Das vorangegangene C\+\+-Producer-Beispiel sendet einen Puffer mit Testdaten. In einer echten Anwendung sollten Sie Frame-Puffer und -Größe aus den Frame-Daten von einer Medienquelle (z. B. einer Kamera) abrufen.
Das `Frame`-Objekt enthält folgende Felder:
+ Frame-Index. Dies sollte ein Wert sein, der gleichmäßig erhöht wird.
+ Dem Frame zugeordnete Flags. Wenn der Encoder beispielsweise zum Generieren eines Keyframes konfiguriert wurde, würde diesem Frame das Flag `FRAME_FLAG_KEY_FRAME` zugewiesen.
+ Zeitstempel dekodieren.
+ Zeitstempel der Präsentation.
+ Dauer des Frames (in 100-ns-Einheiten).
+ Größe des Frames in Byte.
+ Framedaten.
Weitere Informationen zum Format des Frames erhalten Sie unter [Kinesis Video Streams Streams-Datenmodell](how-data.md).
## Fügen Sie einen KinesisVideoFrame in einen bestimmten Titel ein von KinesisVideoStream
Sie können die `PutFrameHelper` Klasse verwenden, um Frame-Daten in eine bestimmte Spur einzufügen. Rufen Sie zunächst den `getFrameDataBuffer` auf, um einen Zeiger auf einen der vorab zugewiesenen Puffer zum Ausfüllen der `KinesisVideoFrame` Daten zu erhalten. Dann können Sie den aufrufen, `putFrameMultiTrack` um den `KinesisVideoFrame` zusammen mit dem booleschen Wert zu senden, der den Typ der Frame-Daten angibt. Verwenden Sie "true", wenn es sich um Videodaten handelt, oder "false", wenn der Frame Audiodaten enthält. Die `putFrameMultiTrack` Methode verwendet einen Warteschlangenmechanismus, um sicherzustellen, dass die MKV-Fragmente monoton ansteigende Frame-Zeitstempel beibehalten und sich zwei beliebige Fragmente nicht überlappen. Beispielsweise sollte der MKV-Zeitstempel des ersten Frames eines Fragments immer größer sein als der MKV-Zeitstempel des letzten Frames des vorherigen Fragments.
Der `PutFrameHelper` hat die folgenden Felder:
+ Maximale Anzahl von Audio-Frames in der Warteschlange.
+ Maximale Anzahl von Videoframes in der Warteschlange.
+ Größe, die einem einzelnen Audioframe zugewiesen werden soll.
+ Größe, die einem einzelnen Videoframe zugewiesen werden soll.
## Zugriff auf Metriken und Metrikprotokollierung
Das C\+\+ Producer SDK umfasst Funktionen für Metriken und die Protokollierung von Metriken.
Sie können die `getKinesisVideoStreamMetrics` API-Operationen `getKinesisVideoMetrics` und verwenden, um Informationen über Kinesis Video Streams und Ihre aktiven Streams abzurufen.
Der folgende Code stammt aus der Datei `kinesis-video-pic/src/client/include/com/amazonaws/kinesis/video/client/Include.h`.
```
/**
* 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);
```
Das von `getKinesisVideoMetrics` gefüllte `PClientMetrics`-Objekt folgende Informationen enthalten:
+ **contentStoreSize:** Die Gesamtgröße des Inhaltsspeichers (der Speicher, der zum Speichern von Streaming-Daten verwendet wird) in Byte.
+ **contentStoreAvailableGröße:** Der verfügbare Speicher im Inhaltsspeicher in Byte.
+ **contentStoreAllocatedGröße:** Der zugewiesene Speicher im Inhaltsspeicher.
+ **totalContentViewsGröße:** Der gesamte Speicher, der für die Inhaltsansicht verwendet wird. Die Inhaltsansicht besteht aus einer Reihe von Informationsindizes im Inhaltsspeicher.
+ **totalFrameRate:** Die Gesamtzahl der Frames pro Sekunde in allen aktiven Streams.
+ **totalTransferRate:** Die Gesamtzahl der Bits pro Sekunde (bps), die in allen Streams gesendet werden.
Das von `getKinesisVideoStreamMetrics` gefüllte `PStreamMetrics`-Objekt folgende Informationen enthalten:
+ **currentViewDuration:** Der Unterschied in 100 ns-Einheiten zwischen dem Kopf der Inhaltsansicht (wenn Frames codiert sind) und der aktuellen Position (wenn Frame-Daten an Kinesis Video Streams gesendet werden).
+ **overallViewDuration:** Der Unterschied in 100 ns-Einheiten zwischen dem Kopf der Inhaltsansicht (wenn Frames codiert sind) und dem Ende (wenn Frames aus dem Speicher gelöscht werden, entweder weil der gesamte zugewiesene Speicherplatz für die Inhaltsansicht überschritten wurde oder weil eine `PersistedAck` Nachricht von Kinesis Video Streams empfangen wird und Frames, von denen bekannt ist, dass sie persistent sind, gelöscht werden).
+ **currentViewSize:** Die Größe der Inhaltsansicht in Byte vom Kopf (wenn Frames codiert sind) bis zur aktuellen Position (wenn Frames an Kinesis Video Streams gesendet werden).
+ **overallViewSize:** Die Gesamtgröße der Inhaltsansicht in Byte.
+ **currentFrameRate:** Die zuletzt gemessene Rate des Streams in Bildern pro Sekunde.
+ **currentTransferRate:** Die zuletzt gemessene Rate des Streams in Byte pro Sekunde.
## Abbruch
Wenn Sie die verbleibenden Bytes in einem Puffer senden und auf das `ACK` warten möchten, können Sie `stopSync` verwenden:
```
kinesis_video_stream->stopSync();
```
Oder Sie können `stop` aufrufen, um das Streamen zu beenden:
```
kinesis_video_stream->stop();
```
Nachdem Sie den Stream gestoppt haben, können Sie den Stream durch Aufrufen der folgenden API freigeben:
```
kinesis_video_producer_->freeStream(kinesis_video_stream);
```