Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Scrivi ed esamina il codice
<a name="producersdk-c-write"></a>

In questa sezione, si esamina il codice dell'applicazione di esempio `KvsVideoOnlyStreamingSample.c` nella `samples` cartella del repository [https://github.com/awslabs/amazon-kinesis-video-streams-producer-c on](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c). GitHub Hai scaricato questo codice nella fase precedente. Questo esempio dimostra come utilizzare la libreria C producer per inviare frame video con codifica H.264 all'interno della `samples/h264SampleFrames` cartella al flusso video Kinesis.

Questa applicazione di esempio ha tre sezioni:
+ Inizializzazione e configurazione:
  + Inizializzazione e configurazione della pipeline dei supporti specifici della piattaforma.
  + Inizializzazione e configurazione KinesisVideoClient e KinesisVideoStream per la pipeline, impostazione dei callback, integrazione dell'autenticazione specifica dello scenario, estrazione e invio di dati privati del codec e trasferimento dello stream allo stato READY.
+ Loop principale:
  + Ottenere il frame dalla pipeline dei supporti con timestamp e flag.
  +  KinesisVideoStreamInvio del frame a.
+ Teardown:
  + Arresto (sincronizzazione) KinesisVideoStream, liberazione, liberazione KinesisVideoStream. KinesisVideoClient

Questa applicazione di esempio completa le attività seguenti:
+ Chiama l'API `createDefaultDeviceInfo` per creare l'oggetto `deviceInfo` che contiene informazioni sul dispositivo o sulla configurazione dello storage.

  ```
  // 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;
  ```
+ Chiama l'API `createRealtimeVideoStreamInfoProvider` per creare l' oggetto `StreamInfo`.

  ```
  CHK_STATUS(createRealtimeVideoStreamInfoProvider(streamName, DEFAULT_RETENTION_PERIOD, DEFAULT_BUFFER_DURATION, &pStreamInfo));
  // adjust members of pStreamInfo here if needed
  ```
+ Chiama l'`createDefaultCallbacksProviderWithAwsCredentials`API per creare il provider di callback predefinito basato su credenziali statiche. AWS 

  ```
  CHK_STATUS(createDefaultCallbacksProviderWithAwsCredentials(accessKey,
                                                                  secretKey,
                                                                  sessionToken,
                                                                  MAX_UINT64,
                                                                  region,
                                                                  cacertPath,
                                                                  NULL,
                                                                  NULL,
                                                                  FALSE,
                                                                  &pClientCallbacks));
  ```
+ Chiama l'`createKinesisVideoClient`API per creare l'`KinesisVideoClient`oggetto che contiene informazioni sull'archiviazione del dispositivo e mantiene i callback per segnalare gli eventi di Kinesis Video Streams.

  ```
  CHK_STATUS(createKinesisVideoClient(pDeviceInfo, pClientCallbacks, &clientHandle));                
  ```
+ Chiama l'API `createKinesisVideoStreamSync` per creare l' oggetto `KinesisVideoStream`.

  ```
  CHK_STATUS(createKinesisVideoStreamSync(clientHandle, pStreamInfo, &streamHandle));                
  ```
+ Configura un frame di esempio e chiama l'API `PutKinesisVideoFrame` per l'invio di frame all'oggetto `KinesisVideoStream`.

  ```
   // 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;
      }
  ```
+ Teardown:

  ```
  CHK_STATUS(stopKinesisVideoStreamSync(streamHandle));
  CHK_STATUS(freeKinesisVideoStream(&streamHandle));
  CHK_STATUS(freeKinesisVideoClient(&clientHandle));
  ```