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.
# Verwenden Sie die C-Producer-Bibliothek
Sie können die von Amazon Kinesis Video Streams bereitgestellte C-Producer-Bibliothek verwenden, um Anwendungscode zu schreiben, um Mediendaten von einem Gerät an einen Kinesis-Videostream zu senden.
## Objektmodell
[Die Kinesis Video Streams C Producer-Bibliothek basiert auf einer gemeinsamen Komponente namens Platform Independent Codebase (PIC), die GitHub unter https://github.com/awslabs/ amazon-kinesis-video-streams -pic/ verfügbar ist.](https://github.com/awslabs/amazon-kinesis-video-streams-pic/) Das PIC enthält plattformunabhängige Geschäftslogik für die grundlegenden Komponenten. Die Kinesis Video Streams C-Producer-Bibliothek umschließt PIC mit einer zusätzlichen API-Ebene, die szenario- und plattformspezifische Rückrufe und Ereignisse ermöglicht. Die Kinesis Video Streams C Producer-Bibliothek besteht aus den folgenden Komponenten, die auf PIC aufbauen:
+ **Anbieter von Geräteinformationen** — Macht die `DeviceInfo` Struktur verfügbar, die direkt an die PIC-API übergeben werden kann. Sie können eine Reihe von Anbietern konfigurieren, einschließlich eines für Anwendungsszenarien optimierten Anbieters, der den Inhaltsspeicher auf der Grundlage der Anzahl und der Typen von Streams, die Ihre Anwendung verarbeitet, und der Menge der erforderlichen Pufferung, die auf der Grundlage der Menge des verfügbaren RAM konfiguriert ist, optimieren kann.
+ **Stream-Informationsanbieter** — Macht die `StreamInfo` Struktur verfügbar, die direkt an die PIC-API übergeben werden kann. Es gibt eine Reihe von Anbietern, die für die Anwendungstypen und die gängigen Arten von Streaming-Szenarien spezifisch sind. Dazu gehören Anbieter wie Video, Audio sowie Audio- und Video-Multitrack. Für jedes dieser Szenarien gibt es Standardwerte, die Sie an die Anforderungen Ihrer Anwendung anpassen können.
+ **Callback-Anbieter** — Macht die `ClientCallbacks` Struktur verfügbar, die direkt an die PIC-API übergeben werden kann. Dazu gehören eine Reihe von Callback-Anbietern für Netzwerke (CURL-basierte API-Callbacks), Autorisierung (AWS Credentials-API) und Callbacks, bei denen das Streaming bei Fehlern wiederholt werden soll. Die Callback Provider-API benötigt für die Konfiguration eine Reihe von Argumenten, wie z. B. die und die Autorisierungsinformationen. AWS-Region Dies erfolgt mithilfe von IoT-Zertifikaten oder mithilfe von AWS AccessKeyId, SecretKey, oder SessionToken. Sie können Callback Provider um benutzerdefinierte Callbacks erweitern, wenn Ihre Anwendung eine Weiterverarbeitung eines bestimmten Callback benötigt, um eine anwendungsspezifische Logik zu erreichen.
+ **FrameOrderCoordinator**— Hilft bei der Audio- und Videosynchronisierung für mehrspurige Szenarien. Es hat ein Standardverhalten, das Sie an die spezifische Logik Ihrer Anwendung anpassen können. Außerdem optimiert es die Paketierung der Frame-Metadaten in der PIC-Framestruktur, bevor sie an die PIC-API der unteren Ebene gesendet werden. Für Nicht-Multitrack-Szenarien ist diese Komponente ein Übergang zur PIC-putFrame-API.
Die C-Bibliothek enthält die folgenden Objekte zum Senden von Daten an einen Kinesis-Videostream:
+ **KinesisVideoClient**— Enthält Informationen über Ihr Gerät und verwaltet Rückrufe, um über Kinesis Video Streams Streams-Ereignisse zu berichten.
+ **KinesisVideoStream**— Stellt Informationen zu den Parametern des Videostreams wie Name, Datenaufbewahrungsdauer und Medieninhaltstyp dar.
## Fügt Medien in den Stream ein
Sie können die von der C-Bibliothek bereitgestellten Methoden verwenden (z. B.`PutKinesisVideoFrame`), um Daten in das `KinesisVideoStream` Objekt einzufügen. Die Bibliothek verwaltet dann den internen Status der Daten. Das umfasst beispielsweise folgende Aufgaben:
+ Durchführen der Authentifizierung.
+ Überwachen auf Netzwerklatenz. Wenn die Latenz zu hoch ist, verwirft die Bibliothek gegebenenfalls Frames.
+ Überwachen des Status des laufenden Streamings.
## Verfahren: Verwenden Sie das C-Producer-SDK
Dieses Verfahren zeigt, wie Sie den Kinesis Video Streams Streams-Client und Medienquellen in einer C-Anwendung verwenden, um H.264-kodierte Videoframes an Ihren Kinesis-Videostream zu senden.
In dieser Vorgehensweise werden die folgenden Schritte beschrieben:
+ [Laden Sie den C-Producer-Bibliothekscode herunter](producersdk-c-download.md)
+ [Schreiben und untersuchen Sie den Code](producersdk-c-write.md)
+ [Führen Sie den Code aus und überprüfen Sie ihn](producersdk-c-test.md)
# Voraussetzungen
Bevor Sie das C Producer SDK einrichten, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:
+ **Anmeldeinformationen** — Im Beispielcode geben Sie Anmeldeinformationen an, indem Sie ein Profil angeben, das Sie in Ihrer Profildatei für AWS Anmeldeinformationen eingerichtet haben. Falls das noch nicht geschehen ist, richten Sie zunächst das Anmeldeinformationsprofil ein.
Weitere Informationen finden Sie unter [AWS Anmeldeinformationen und Region für die Entwicklung einrichten](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).
+ **Integration des Zertifikatsspeichers** — Die Kinesis Video Streams Streams-Producer-Bibliothek muss eine Vertrauensstellung mit dem von ihr aufgerufenen Dienst aufbauen. Dies erfolgt durch die Validierung der Zertifizierungsstellen (CAs) im öffentlichen Zertifikatsspeicher. Bei Linux-basierten Modellen befindet sich dieser Speicher im Verzeichnis „`/etc/ssl`“.
Laden Sie das Zertifikat aus dem folgenden Speicherort in den Zertifikatspeicher:
[https://www.amazontrust.com/repository/SFSRootCAG2.pem](https://www.amazontrust.com/repository/SFSRootCAG2.pem)
+ Installieren Sie die folgenden Build-Abhängigkeiten für macOS:
+ [Autoconf 2.69](http://www.gnu.org/software/autoconf/autoconf.html) (Lizenz GPLv3 \$1/Autoconf: GNU GPL Version 3 oder höher)
+ [CMake 3.7 oder 3.8](https://cmake.org/)
+ [Pkg-Config](https://www.freedesktop.org/wiki/Software/pkg-config/)
+ xCode (macOS)/clang/gcc (xcode-select Version 2347)
+ Java Development Kit (JDK) (für Java-JNI-Kompilierung)
+ [Lib-Pkg](https://github.com/freebsd/pkg/tree/master/libpkg)
+ Installieren Sie die folgenden Build-Abhängigkeiten für Ubuntu:
+ Git: `sudo apt install git`
+ [CMake](http://kitware.com/cmake): `sudo apt install cmake`
+ G \$1\$1: `sudo apt install g++`
+ pkg-konfiguration: `sudo apt install pkg-config`
+ OpenJDK: `sudo apt install openjdk-8-jdk`
+ Legen Sie die `JAVA_HOME`-Umgebungsvariable fest: `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/`
# Laden Sie den C-Producer-Bibliothekscode herunter
In diesem Abschnitt laden Sie die Low-Level-Bibliotheken herunter. Die Voraussetzungen und anderen Details für dieses Beispiel finden Sie unter [Verwenden Sie die C\$1\$1-Producer-Bibliothek](producer-sdk-cpp.md).
1. Erstellen Sie ein Verzeichnis und klonen Sie dann den Beispielquellcode aus dem GitHub Repository.
```
git clone --recursive https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git
```
**Anmerkung**
Wenn Sie es verabsäumen, git clone mit `--recursive` auszuführen, führen Sie `git submodule update --init` im Verzeichnis `amazon-kinesis-video-streams-producer-c/open-source` aus. Sie müssen auch pkg-config und eine Build-Umgebung installieren. CMake
[Weitere Informationen finden Sie `README.md` in https://github.com/awslabs/ amazon-kinesis-video-streams -producer-c.git.](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git)
1. Öffnen Sie den Code in einer integrierten Entwicklungsumgebung (Integrated Development Environment, IDE) Ihrer Wahl (z. B. [Eclipse](https://www.eclipse.org/)).
# Schreiben und untersuchen Sie den Code
In diesem Abschnitt untersuchen Sie den Code der Beispielanwendung `KvsVideoOnlyStreamingSample.c` im `samples` Ordner des Repositorys [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c). GitHub Sie haben diesen Code im vorherigen Schritt heruntergeladen. Dieses Beispiel zeigt, wie Sie die C-Producer-Bibliothek verwenden, um H.264-kodierte Videoframes innerhalb des Ordners an Ihren Kinesis-Videostream `samples/h264SampleFrames` zu senden.
Diese Beispielanwendung hat drei Abschnitte:
+ Initialisierung und Konfiguration:
+ Initialisieren und Konfigurieren der plattformspezifischen Medien-Pipeline.
+ Initialisierung und Konfiguration von KinesisVideoClient und KinesisVideoStream für die Pipeline, Einstellung der Callbacks, Integration der szenariospezifischen Authentifizierung, Extrahieren und Senden von privaten Codec-Daten und Versetzen des Streams in den Status READY.
+ Hauptschleife:
+ Abrufen des Frame von der Medien-Pipeline mit dem Zeitstempel und Flags.
+ Senden des Frames an den. KinesisVideoStream
+ Abbau:
+ Stoppen (Synchronisieren) KinesisVideoStream, Freigeben KinesisVideoStream, KinesisVideoClient Freigeben.
Diese Beispielanwendung erfüllt die folgenden Aufgaben:
+ Aufruf der `createDefaultDeviceInfo`-API zur Erstellung des `deviceInfo`-Objekts mit den Daten zum Gerät bzw. zur Speicherkonfiguration.
```
// 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;
```
+ Aufruf der `createRealtimeVideoStreamInfoProvider`-API zur Erstellung des `StreamInfo`-Objekts.
```
CHK_STATUS(createRealtimeVideoStreamInfoProvider(streamName, DEFAULT_RETENTION_PERIOD, DEFAULT_BUFFER_DURATION, &pStreamInfo));
// adjust members of pStreamInfo here if needed
```
+ Rufen Sie die `createDefaultCallbacksProviderWithAwsCredentials` API auf, um den Standard-Callback-Anbieter auf der Grundlage statischer Anmeldeinformationen zu erstellen. AWS
```
CHK_STATUS(createDefaultCallbacksProviderWithAwsCredentials(accessKey,
secretKey,
sessionToken,
MAX_UINT64,
region,
cacertPath,
NULL,
NULL,
FALSE,
&pClientCallbacks));
```
+ Rufen Sie die `createKinesisVideoClient` API auf, um das `KinesisVideoClient` Objekt zu erstellen, das Informationen über Ihren Gerätespeicher enthält und Callbacks verwaltet, um über Kinesis Video Streams Streams-Ereignisse zu berichten.
```
CHK_STATUS(createKinesisVideoClient(pDeviceInfo, pClientCallbacks, &clientHandle));
```
+ Aufruf der `createKinesisVideoStreamSync`-API zur Erstellung des `KinesisVideoStream`-Objekts.
```
CHK_STATUS(createKinesisVideoStreamSync(clientHandle, pStreamInfo, &streamHandle));
```
+ Einrichten eines Beispiel-Frame und Aufruf der `PutKinesisVideoFrame`-API zur Übermittlung dieses Frame an das `KinesisVideoStream`-Objekt.
```
// 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;
}
```
+ Abbau:
```
CHK_STATUS(stopKinesisVideoStreamSync(streamHandle));
CHK_STATUS(freeKinesisVideoStream(&streamHandle));
CHK_STATUS(freeKinesisVideoClient(&clientHandle));
```
# Führen Sie den Code aus und überprüfen Sie ihn
Gehen Sie wie folgt vor[Verwenden Sie die C\$1\$1-Producer-Bibliothek](producer-sdk-cpp.md), um den Code für auszuführen und zu überprüfen:
1. Führen Sie die folgenden Befehle aus, um ein `build` Verzeichnis in Ihrem [heruntergeladenen C-SDK](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git) zu erstellen, und starten Sie es `cmake` von dort aus:
```
mkdir -p amazon-kinesis-video-streams-producer-c/build;
cd amazon-kinesis-video-streams-producer-c/build;
cmake ..
```
Sie können die folgenden Optionen an `cmake ..` übergeben:
+ `-DBUILD_DEPENDENCIES`- ob abhängige Bibliotheken aus dem Quellcode erstellt werden sollen.
+ `-DBUILD_TEST=TRUE`- Einheiten- und Integrationstests erstellen. Könnte nützlich sein, um die Unterstützung für Ihr Gerät zu bestätigen.
`./tst/webrtc_client_test`
+ `-DCODE_COVERAGE`- ermöglicht die Berichterstattung über die Netzabdeckung.
+ `-DCOMPILER_WARNINGS`- aktiviert alle Compiler-Warnungen.
+ `-DADDRESS_SANITIZER`- baue mit AddressSanitizer.
+ `-DMEMORY_SANITIZER`- baue mit MemorySanitizer.
+ `-DTHREAD_SANITIZER`- baue mit ThreadSanitizer.
+ `-DUNDEFINED_BEHAVIOR_SANITIZER`- baue mit UndefinedBehaviorSanitizer.
+ `-DALIGNED_MEMORY_MODEL` – Build für Geräte mit ausgerichtetem Memory Model Der Standardwert ist `OFF`.
1. Navigieren Sie zu dem `build` Verzeichnis, das Sie gerade mit dem vorherigen Schritt erstellt haben, und führen Sie den Befehl aus, `make` um das WebRTC C SDK und die bereitgestellten Beispiele zu erstellen.
```
make
```
1. Die Beispielanwendung `kinesis_video_cproducer_video_only_sample` sendet h.264-kodierte Videoframes innerhalb des Ordners `samples/h264SampleFrames` an Kinesis Video Streams. Mit dem folgenden Befehl werden die Videoframes zehn Sekunden lang in einer Schleife an Kinesis Video Streams gesendet:
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10
```
Wenn Sie H.264-kodierte Frames aus einem anderen Ordner senden möchten (z. B.`MyH264FramesFolder`), führen Sie das Beispiel mit den folgenden Argumenten aus:
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10 MyH264FramesFolder
```
1. Definieren Sie die C-Definitionen `HEAP_DEBUG` und `LOG_STREAMING`, indem Sie die entsprechenden Zeilen in `CMakeList.txt` auskommentieren, um ausführliche Protokolle zu aktivieren.
Sie können den Fortschritt der Testsuite in der Debug-Ausgabe in der IDE überwachen. Sie können den Traffic in Ihrem Stream auch überwachen, indem Sie sich die mit Ihrem Stream verknüpften Metriken in der CloudWatch Amazon-Konsole ansehen, z. `PutMedia.IncomingBytes` B.
**Anmerkung**
Da der Testeinsatz nur Frames mit leeren Bytes sendet, zeigt die Konsole die Daten nicht als Videostream an.