Schritt 2: Schreiben und untersuchen Sie den Code

In diesem Abschnitt der Vorgehensweise zur C++ Producer-Bibliothek untersuchen Sie den Code im C++-Testeinsatz (tst/ProducerTestFixture.h und andere Dateien). Sie haben diesen Code im vorherigen Abschnitt heruntergeladen.

Das plattformunabhängige C++-Beispiel zeigt das folgende Codierungsmuster:

• Erstellen Sie eine Instanz vonKinesisVideoProducer, 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.

Eine Instanz von erstellen 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.

Eine Instanz von erstellen 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<StreamDefinition>(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 Management Console angezeigt werden.

• AWS KMS Verschlüsselungsschlüssel für den Stream. Weitere Informationen finden Sie unter Serverseitige Verschlüsselung mit Kinesis Video Streams verwenden.

• 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.

Hinzufügen einer Audiospur zum Kinesis-Videostream

Sie können einer Videotrack-Stream-Definition Details zur Audiospur hinzufügen, indem Sie die addTrack-Methode von verwenden: StreamDefinition

stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO);

Für die addTrack-Methode sind folgende Parameter erforderlich:

• 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

Einfügen eines Frames in den Kinesis-Videostream

Sie fügen Medien in den Kinesis-Videostream einKinesisVideoStream::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::nanoseconds>(
                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 vorstehende 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 finden Sie unter Kinesis Video Streams Streams-Datenmodell.

Einfügen eines KinesisVideoFrame in einen bestimmten Track von KinesisVideoStream

Sie können die PutFrameHelper Klasse verwenden, um Frame-Daten in eine bestimmte Spur einzufügen. Rufen Sie zunächst den getFrameData Buffer auf, um einen Zeiger auf einen der vorab zugewiesenen Puffer zum Ausfüllen der KinesisVideoFrame Daten zu erhalten. Anschließend können Sie den putFrameMulti Track aufrufen, 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 putFrameMulti Track-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 Audioframes 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.

Metriken und Metrikprotokollierung

Das C++ Producer SDK umfasst Funktionen für Metriken und Metrikprotokollierung.

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); 
            

Nächster Schritt

Schritt 3: Führen Sie den Code aus und überprüfen Sie ihn