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
In questa sezione di[Usa la libreria Producer C\+\+](producer-sdk-cpp.md), si esamina il codice nel test harness C\+\+ (`tst/ProducerTestFixture.h`e in altri file). Hai scaricato questo codice nella sezione precedente.
L'esempio di C\+\+ **indipendente dalla piattaforma** mostra i seguenti modelli di codifica:
+ Crea un'istanza di `KinesisVideoProducer` per accedere a Kinesis Video Streams.
+ Creare un'istanza di `KinesisVideoStream`. Questo crea un flusso video Kinesis nel tuo Account AWS se non esiste già uno stream con lo stesso nome.
+ Chiama `putFrame` in `KinesisVideoStream` per ogni fotogramma di dati, non appena diventa disponibile, per inviarlo al flusso.
Le sezioni seguenti forniscono ulteriori informazioni su questo modello di codifica.
## Crea un'istanza di KinesisVideoProducer
Per creare l'oggetto `KinesisVideoProducer`, richiama il metodo `KinesisVideoProducer::createSync`. L'esempio seguente crea `KinesisVideoProducer` nel file `ProducerTestFixture.h`:
```
kinesis_video_producer_ = KinesisVideoProducer::createSync(move(device_provider_),
move(client_callback_provider_),
move(stream_callback_provider_),
move(credential_provider_),
defaultRegion_);
```
Il metodo `createSync` accetta i parametri seguenti:
+ Un oggetto `DeviceInfoProvider`, che restituisce un oggetto `DeviceInfo` contenente informazioni sul dispositivo o sulla configurazione dello storage.
**Nota**
Puoi configurare la dimensione dello store dei contenuti utilizzando il parametro `deviceInfo.storageInfo.storageSize`. I flussi di contenuti condividono lo store dei contenuti. Per determinare i requisiti delle dimensioni di storage, moltiplica la dimensione media dei fotogrammi per il numero di fotogrammi archiviati per la durata massima di tutti i flussi. Quindi moltiplica per 1,2 per prendere in considerazione la deframmentazione. Supponi, ad esempio, che la tua applicazione abbia la seguente configurazione:
Tre flussi
3 minuti di durata massima
Ogni flusso è di 30 fotogrammi al secondo (FPS)
Ogni fotogramma ha una dimensione di 10.000 KB
Il requisito di archiviazione dei contenuti per questa applicazione è **3 (stream) \* 3 (minuti) \* 60 (secondi al minuto) \* 10000 (kb) \* 1,2 (margine di deframmentazione) = 194,4** Mb \~ 200 Mb.
+ Un oggetto `ClientCallbackProvider`, che restituisce puntatori delle funzioni che segnalano eventi specifici del client.
+ Un oggetto `StreamCallbackProvider`, che restituisce puntatori delle funzioni richiamati quando si verificano eventi specifici del flusso.
+ Un `CredentialProvider` oggetto che fornisce l'accesso alle variabili di ambiente delle credenziali. AWS
+ Il Regione AWS («us-west-2"). L'endpoint del servizio è determinato dalla regione.
## Crea un'istanza di KinesisVideoStream
Per creare l'oggetto `KinesisVideoStream`, richiama il metodo `KinesisVideoProducer::CreateStream` con un parametro `StreamDefinition`. L'esempio crea `KinesisVideoStream` nel file `ProducerTestFixture.h` con il tipo di traccia video e con id traccia pari a 1:
```
auto stream_definition = make_unique(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));
```
L'oggetto `StreamDefinition` dispone dei campi seguenti:
+ Nome del flusso.
+ Periodo di retention dei dati.
+ Tag per il flusso. Questi tag possono essere utilizzati dalle applicazioni dei consumatori per trovare il flusso corretto o per avere maggiori informazioni sul flusso. I tag possono anche essere visualizzati in Console di gestione AWS.
+ AWS KMS chiave di crittografia per lo stream. Per ulteriori informazioni, consulta [Protezione dei dati in Kinesis Video Streams](how-kms.md).
+ Tipo di streaming. Attualmente, l'unico valore valido è `STREAMING_TYPE_REALTIME`.
+ Tipo di contenuti multimediali.
+ Latenza file multimediali. Questo valore non è attualmente utilizzato e deve essere impostato su 0.
+ Durata della riproduzione di ogni frammento.
+ Scala del timecode dei file multimediali.
+ Se i file multimediali usano la frammentazione del fotogramma chiave.
+ Se i file multimediali utilizzano i timecode.
+ Se i file multimediali usano i tempi assoluti del frammento.
## Aggiungere una traccia audio allo stream video Kinesis
È possibile aggiungere i dettagli della traccia audio a una definizione di flusso di tracce video utilizzando il `addTrack` metodo di`StreamDefinition`:
```
stream_definition->addTrack(DEFAULT_AUDIO_TRACKID, DEFAULT_AUDIO_TRACK_NAME, DEFAULT_AUDIO_CODEC_ID, MKV_TRACK_INFO_TYPE_AUDIO);
```
Il `addTrack` metodo richiede i seguenti parametri:
+ ID della traccia (come una traccia per l'audio). Questo deve essere unico e un valore diverso da zero.
+ Nome della traccia definito dall'utente (ad esempio, «audio» per la traccia audio).
+ ID codec per questa traccia (ad esempio, per la traccia audio «A\_AAC»).
+ Tipo di traccia (ad esempio, utilizzate il valore enum di MKV\_TRACK\_INFO\_TYPE\_AUDIO per l'audio).
Se si dispone di dati provati codec per la traccia audio, è possibile passarli quando si chiama la funzione addTrack. È inoltre possibile inviare i dati privati del codec dopo aver creato l'oggetto durante la chiamata al metodo start in. KinesisVideoStream KinesisVideoStream
## Inserisci un fotogramma nel flusso video di Kinesis
I file multimediali vengono inseriti nel flusso video di Kinesis utilizzando`KinesisVideoStream::putFrame`, passando un `Frame` oggetto che contiene l'intestazione e i dati multimediali. L'esempio richiama `putFrame` nel file `ProducerApiTest.cpp`:
```
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::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));
```
**Nota**
Il precedente esempio di produttore in C\+\+ invia un buffer di dati di test. In un'applicazione reale, è consigliabile ottenere il buffer e la dimensione del fotogramma dai dati del fotogramma da un'origine multimediale (ad esempio una fotocamera).
L'oggetto `Frame` dispone dei campi seguenti:
+ Indice dei fotogrammi. Deve essere un valore a incremento monotono.
+ Flag associati al fotogramma. Ad esempio, se il codificatore è stato configurato per ottenere un fotogramma chiave, a questo fotogramma verrà assegnato il contrassegno `FRAME_FLAG_KEY_FRAME`.
+ Timestamp di decodifica.
+ Timestamp della presentazione.
+ Durata del fotogramma (in unità di 100 ns).
+ Dimensione del fotogramma in byte.
+ Dati del fotogramma.
Per ulteriori informazioni sul formato della cornice, vedere. [Modello di dati Kinesis Video Streams](how-data.md)
## Inserisci un KinesisVideoFrame in una traccia specifica di KinesisVideoStream
Puoi usare la `PutFrameHelper` classe per inserire i dati del frame in una traccia specifica. Innanzitutto, chiama il `getFrameDataBuffer` per ottenere un puntatore a uno dei buffer preallocati per inserire i dati. `KinesisVideoFrame` Quindi, puoi chiamare il `putFrameMultiTrack` per inviare il `KinesisVideoFrame` insieme al valore booleano per indicare il tipo di dati del frame. Utilizza "true" se si tratta di dati video o "false" se il frame contiene dati audio. Il `putFrameMultiTrack` metodo utilizza un meccanismo di accodamento per garantire che i frammenti MKV mantengano timestamp dei frame crescenti in modo monotono e che due frammenti non si sovrappongano. Ad esempio, il timestamp MKV del primo fotogramma di un frammento dovrebbe essere sempre maggiore del timestamp MKV dell'ultimo fotogramma del frammento precedente.
Ha i seguenti campi: `PutFrameHelper`
+ Numero massimo di frame audio nella coda.
+ Numero massimo di fotogrammi video nella coda.
+ Dimensione da allocare per un singolo frame audio.
+ Dimensioni da allocare per un singolo fotogramma video.
## Accedi alle metriche e alla registrazione delle metriche
L'SDK C\+\+ Producer include funzionalità per le metriche e la registrazione delle metriche.
Puoi utilizzare le operazioni `getKinesisVideoMetrics` e `getKinesisVideoStreamMetrics` API per recuperare informazioni su Kinesis Video Streams e sui tuoi stream attivi.
Il seguente codice è tratto dal file `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);
```
L'oggetto `PClientMetrics` compilato da `getKinesisVideoMetrics` contiene le seguenti informazioni:
+ **contentStoreSize:** La dimensione complessiva in byte dell'archivio di contenuti (la memoria utilizzata per archiviare i dati in streaming).
+ **contentStoreAvailableDimensione:** la memoria disponibile nell'archivio dei contenuti, in byte.
+ **contentStoreAllocatedDimensione:** la memoria allocata nell'archivio dei contenuti.
+ **totalContentViewsDimensione:** la memoria totale utilizzata per la visualizzazione dei contenuti. La visualizzazione dei contenuti è una serie di indici di informazioni presenti nell'archivio dei contenuti.
+ **totalFrameRate:** il numero aggregato di frame al secondo in tutti gli stream attivi.
+ **totalTransferRate:** Il totale di bit al secondo (bps) inviati in tutti i flussi.
L'oggetto `PStreamMetrics` compilato da `getKinesisVideoStreamMetrics` contiene le seguenti informazioni:
+ **currentViewDuration:** La differenza in unità di 100 ns tra l'inizio della vista del contenuto (quando i frame sono codificati) e la posizione corrente (quando i dati dei frame vengono inviati a Kinesis Video Streams).
+ **overallViewDuration:** La differenza in unità di 100 ns tra l'inizio della vista del contenuto (quando i frame sono codificati) e la parte finale (quando i frame vengono eliminati dalla memoria, o perché viene superato lo spazio totale allocato per la visualizzazione del contenuto o perché viene `PersistedAck` ricevuto un messaggio da Kinesis Video Streams e i frame noti per essere persistenti vengono svuotati).
+ **currentViewSize:** La dimensione in byte della visualizzazione del contenuto dall'intestazione (quando i frame sono codificati) alla posizione corrente (quando i frame vengono inviati a Kinesis Video Streams).
+ **overallViewSize:** La dimensione totale in byte della visualizzazione del contenuto.
+ **currentFrameRate:** L'ultima velocità misurata dello stream, in fotogrammi al secondo.
+ **currentTransferRate:** L'ultima velocità misurata dello stream, in byte al secondo.
## Teardown:
Se desideri inviare i byte rimanenti in un buffer e attendere il `ACK`, puoi utilizzare `stopSync`:
```
kinesis_video_stream->stopSync();
```
In alternativa, puoi chiamare `stop` per terminare lo streaming:
```
kinesis_video_stream->stop();
```
Dopo aver arrestato il flusso, puoi liberarlo richiamando la seguente API:
```
kinesis_video_producer_->freeStream(kinesis_video_stream);
```