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à.
# Usa la libreria C producer
Puoi utilizzare la libreria C producer fornita da Amazon Kinesis Video Streams per scrivere codice applicativo per inviare dati multimediali da un dispositivo a un flusso video Kinesis.
## Modello a oggetti
[La libreria di produttori Kinesis Video Streams C si basa su un componente comune chiamato Platform Independent Codebase (PIC), disponibile GitHub all'indirizzo -pic/. https://github.com/awslabs/ amazon-kinesis-video-streams](https://github.com/awslabs/amazon-kinesis-video-streams-pic/) Il PIC contiene una logica di business indipendente dalla piattaforma per i componenti fondamentali. La libreria di produttori Kinesis Video Streams C include PIC con un livello di API aggiuntivo che consente callback ed eventi specifici per scenari e piattaforme. La libreria di produttori Kinesis Video Streams C ha i seguenti componenti basati su PIC:
+ **Provider di informazioni sui dispositivi**: espone la `DeviceInfo` struttura che può essere fornita direttamente all'API PIC. È possibile configurare un set di provider, incluso un provider ottimizzato per gli scenari applicativi in grado di ottimizzare l'archivio di contenuti in base al numero e ai tipi di flussi gestiti dall'applicazione e alla quantità di buffering richiesta configurata in base alla quantità di RAM disponibile.
+ **Stream info provider**: espone la `StreamInfo` struttura che può essere fornita direttamente all'API PIC. Esiste una serie di provider specifici per i tipi di applicazioni e i tipi più comuni di scenari di streaming. Questi includono provider come video, audio e multitraccia audio e video. Ciascuno di questi scenari presenta impostazioni predefinite che è possibile personalizzare in base ai requisiti dell'applicazione.
+ **Provider di callback**: espone la `ClientCallbacks` struttura che può essere fornita direttamente all'API PIC. Ciò include un set di provider di callback per il networking (callback API basati su CURL), l'autorizzazione (API delle AWS credenziali) e lo streaming di nuovi tentativi in caso di callback di errori. L'API Callback Provider richiede una serie di argomenti per la configurazione, come le informazioni di autorizzazione e. Regione AWS Questa operazione viene eseguita utilizzando certificati IoT o utilizzando AWS AccessKeyId SecretKey, o SessionToken. È possibile potenziare i provider di callback con callback personalizzati se l'applicazione ha bisogno di ulteriori elaborazioni di un determinato callback per raggiungere la logica specifica dell'applicazione.
+ **FrameOrderCoordinator**— Aiuta a gestire la sincronizzazione audio e video per scenari multitraccia. Ha un comportamento predefinito, che è possibile personalizzare per gestire la logica specifica dell'applicazione. Inoltre, semplifica l'imballaggio dei metadati dei frame nella struttura PIC Frame prima di inviarli all'API PIC di livello inferiore. Per gli scenari non multitraccia, questo componente è un punto di passaggio all'API putFrame PIC.
La libreria C fornisce i seguenti oggetti per gestire l'invio di dati a un flusso video di Kinesis:
+ **KinesisVideoClient**— Contiene informazioni sul dispositivo e mantiene i callback per segnalare gli eventi di Kinesis Video Streams.
+ **KinesisVideoStream**— Rappresenta informazioni sui parametri del flusso video, come nome, periodo di conservazione dei dati e tipo di contenuto multimediale.
## Inserite contenuti multimediali nello stream
È possibile utilizzare i metodi forniti dalla libreria C (ad esempio`PutKinesisVideoFrame`) per inserire dati nell'`KinesisVideoStream`oggetto. La libreria gestisce quindi lo stato interno dei dati, che può includere le seguenti attività:
+ Esecuzione dell'autenticazione.
+ Controllo della latenza di rete. Se la latenza è troppo elevata, la libreria potrebbe scegliere di eliminare i fotogrammi.
+ Monitoraggio dello stato dello streaming in corso.
## Procedura: utilizzare C Producer SDK
Questa procedura dimostra come utilizzare il client Kinesis Video Streams e le sorgenti multimediali in un'applicazione C per inviare fotogrammi video con codifica H.264 al flusso video Kinesis.
La procedura include le seguenti fasi:
+ [Scarica il codice della libreria C Producer](producersdk-c-download.md)
+ [Scrivi ed esamina il codice](producersdk-c-write.md)
+ [Esegui e verifica il codice](producersdk-c-test.md)
# Prerequisiti
Prima di configurare C Producer SDK, assicurati di avere i seguenti prerequisiti:
+ **Credenziali**: nel codice di esempio, fornite le credenziali specificando un profilo che avete impostato nel file di profilo delle credenziali. AWS Se non lo hai già fatto, configura prima il profilo delle credenziali.
Per ulteriori informazioni, consulta [Configurare le AWS credenziali](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html) e la regione per lo sviluppo.
+ **Integrazione dell'archivio certificati**: la libreria dei produttori di Kinesis Video Streams deve stabilire un rapporto di fiducia con il servizio che chiama. Ciò avviene tramite la convalida delle autorità di certificazione (CAs) nell'archivio di certificati pubblico. Sui modelli basati su Linux, questo store si trova nella directory `/etc/ssl`/.
Scarica il certificato dal percorso seguente per lo store dei certificati:
[https://www.amazontrust.com/repository/SFSRootCAG2.pem](https://www.amazontrust.com/repository/SFSRootCAG2.pem)
+ Installa le seguenti dipendenze di build per macOS:
+ [Autoconf 2.69](http://www.gnu.org/software/autoconf/autoconf.html) (Licenza GPLv3 \$1/Autoconf: GNU GPL versione 3 o successiva)
+ [CMake 3.7 o 3.8](https://cmake.org/)
+ [Pkg-Config](https://www.freedesktop.org/wiki/Software/pkg-config/)
+ xCode (macOS) / clang / gcc (xcode-select versione 2347)
+ Java Development Kit (JDK) (per la compilazione di Java JNI)
+ [Lib-Pkg](https://github.com/freebsd/pkg/tree/master/libpkg)
+ Installa le seguenti dipendenze di build per Ubuntu:
+ Git: `sudo apt install git`
+ [CMake](http://kitware.com/cmake): `sudo apt install cmake`
+ G\$1\$1: `sudo apt install g++`
+ configurazione pkg: `sudo apt install pkg-config`
+ OpenJDK: `sudo apt install openjdk-8-jdk`
+ Imposta la variabile di ambiente `JAVA_HOME`: `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/`
# Scarica il codice della libreria C Producer
In questa sezione sarà possibile scaricare le librerie di basso livello. Per i prerequisiti e altri dettagli su questo esempio, vedere[Usa la libreria Producer C\$1\$1](producer-sdk-cpp.md).
1. Create una directory, quindi clonate il codice sorgente di esempio dal GitHub repository.
```
git clone --recursive https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git
```
**Nota**
Se non si esegue Git clone con `--recursive`, eseguire `git submodule update --init` nella directory `amazon-kinesis-video-streams-producer-c/open-source`. È inoltre necessario installare pkg-config e un ambiente di CMake compilazione.
[Per maggiori informazioni, consulta in -producer-c.git`README.md`. https://github.com/awslabs/ amazon-kinesis-video-streams](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git)
1. Apri il codice nell'ambiente di sviluppo integrato (IDE) di tua scelta (ad esempio, [Eclipse](https://www.eclipse.org/)).
# Scrivi ed esamina il codice
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));
```
# Esegui e verifica il codice
Per eseguire e verificare il codice per il[Usa la libreria Producer C\$1\$1](producer-sdk-cpp.md), procedi come segue:
1. Esegui i seguenti comandi per creare una `build` directory nell'[SDK C scaricato](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git) e avviala `cmake` da essa:
```
mkdir -p amazon-kinesis-video-streams-producer-c/build;
cd amazon-kinesis-video-streams-producer-c/build;
cmake ..
```
È possibile inviare le seguenti opzioni a `cmake ..`
+ `-DBUILD_DEPENDENCIES`- se creare librerie dipendenti dai sorgenti.
+ `-DBUILD_TEST=TRUE`- build unit e test di integrazione. Potrebbe essere utile per confermare il supporto per il tuo dispositivo.
`./tst/webrtc_client_test`
+ `-DCODE_COVERAGE`- abilitare la segnalazione della copertura.
+ `-DCOMPILER_WARNINGS`- abilita tutti gli avvisi del compilatore.
+ `-DADDRESS_SANITIZER`- costruisci con. AddressSanitizer
+ `-DMEMORY_SANITIZER`- costruisci con MemorySanitizer.
+ `-DTHREAD_SANITIZER`- costruisci con ThreadSanitizer.
+ `-DUNDEFINED_BEHAVIOR_SANITIZER`- costruisci con UndefinedBehaviorSanitizer.
+ `-DALIGNED_MEMORY_MODEL`: compilazione per dispositivi solo con modello di memoria allineato Il valore predefinito è “`OFF`”.
1. Passa alla `build` directory che hai appena creato con il passaggio precedente ed esegui `make` per creare l'SDK WebRTC C e gli esempi forniti.
```
make
```
1. L'applicazione di esempio `kinesis_video_cproducer_video_only_sample` invia fotogrammi video con codifica h.264 all'interno della cartella a Kinesis `samples/h264SampleFrames` Video Streams. Il seguente comando invia i fotogrammi video in loop per dieci secondi a Kinesis Video Streams:
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10
```
Se desideri inviare frame con codifica H.264 da un'altra cartella (ad esempio,`MyH264FramesFolder`), esegui l'esempio con i seguenti argomenti:
```
./kinesis_video_cproducer_video_only_sample YourStreamName 10 MyH264FramesFolder
```
1. Per abilitare i log verbose, crea le definizioni C `HEAP_DEBUG` e `LOG_STREAMING` rimuovendo i commenti dalla righe appropriate in `CMakeList.txt`.
Puoi monitorare l'avanzamento della suite di test nell'output di debug nell'IDE. Puoi anche monitorare il traffico sul tuo stream guardando le metriche associate al tuo stream nella CloudWatch console Amazon, ad esempio`PutMedia.IncomingBytes`.
**Nota**
Poiché il test harness invia solo fotogrammi di byte vuoti, la console non visualizza i dati come un flusso di video.