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
<a name="producersdk-c-write"></a>

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