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 Producer C\$1\$1 Puoi utilizzare la libreria C\$1\$1 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 C\$1\$1 fornisce i seguenti oggetti per gestire l'invio di dati a un flusso video Kinesis: + **KinesisVideoProducer:** contiene informazioni sulla fonte multimediale e sulle AWS credenziali e mantiene i callback per segnalare gli eventi di Kinesis Video Streams. + **KinesisVideoStream:** rappresenta il flusso video di Kinesis. Contiene informazioni sui parametri del flusso video, come nome, periodo di conservazione dei dati e tipo di contenuto multimediale. ## Inserisci contenuti multimediali nello stream È possibile utilizzare i metodi forniti dalla libreria C\$1\$1 (ad esempio,`PutFrame`) 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. ## Interfacce di callback Questo livello mostra un set di interfacce di richiamata, che consentono la comunicazione con il livello dell'applicazione. Queste interfacce di richiamata includono: + **Service callbacks interface (`CallbackProvider`):** la libreria richiama gli eventi ottenuti tramite questa interfaccia quando crea uno stream, ottiene una descrizione dello stream ed elimina uno stream. + **Interfaccia Client-ready o low storage events interface (`ClientCallbackProvider`):** la libreria richiama gli eventi su questa interfaccia quando il client è pronto o quando rileva che potrebbe esaurire lo storage o la memoria disponibili. + **Stream events callback interface (`StreamCallbackProvider`):** la libreria richiama gli eventi su questa interfaccia quando si verificano eventi di streaming, come lo stream che entra nello stato pronto, i frame persi o gli errori di flusso. Kinesis Video Streams fornisce implementazioni predefinite per queste interfacce. Puoi anche fornire un'implementazione personalizzata, ad esempio se hai bisogno di una logica di rete personalizzata o desideri esporre all'interfaccia utente una condizione di archiviazione ridotta. Per ulteriori informazioni sui callback nelle librerie dei produttori, consulta. [Richiamate SDK di Producer](producer-reference-callbacks.md) ## Procedura: utilizzare il C\$1\$1 Producer SDK Questa procedura dimostra come utilizzare il client Kinesis Video Streams e le sorgenti multimediali in un'applicazione C\$1\$1 per inviare dati al flusso video Kinesis. La procedura include le seguenti fasi: **Topics** # Prerequisiti Prima di configurare C\$1\$1 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` **Nota** Questo è necessario solo se stai creando Java Native Interface (JNI). + Imposta la variabile di ambiente `JAVA_HOME`: `export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64/` # Scarica e configura il codice della libreria C\$1\$1 Producer Per informazioni su come scaricare e configurare la libreria di produttori C\$1\$1, consulta [Amazon Kinesis Video Streams CPP](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp) Producer, Plugin e JNI. GStreamer Per i prerequisiti e ulteriori informazioni su questo esempio, consulta. [Usa la libreria Producer C\$1\$1](producer-sdk-cpp.md) ## CMake argomenti Di seguito è riportata una tabella di riferimento per gli argomenti specifici di C\$1\$1 Producer SDK CMake . Puoi anche passare le [ CMake opzioni standard](https://cmake.org/cmake/help/latest/manual/cmake-env-variables.7.html) a CMake . **Importante** Sono tutte opzionali. **Bandiere per includere o escludere determinate funzionalità** | CMake argomento | Tipo | Predefinita | Spiegazione | | --- | --- | --- | --- | | `BUILD_DEPENDENCIES` | Booleano | ATTIVATO | Crea dipendenze dal codice sorgente. Altrimenti, usa le dipendenze già installate nel sistema. Se non è possibile trovare una delle dipendenze richieste, verrà restituito un errore. | | `BUILD_GSTREAMER_PLUGIN` | Booleano | OFF | Costruisce il plugin. kvssink GStreamer | | `BUILD_JNI` | Booleano | OFF | Crea la Java Native Interface (JNI) per poter richiamare questo codice da un ambiente di runtime Java. | | `ALIGNED_MEMORY_MODEL` | Booleano | OFF | Se le allocazioni di memoria devono essere allineate ai limiti di 8 byte. Alcune architetture non consentono l'accesso non allineato alla memoria. | | `CONSTRAINED_DEVICE` | Booleano | OFF | Solo prodotti non Windows. Quando è attivo, imposta la dimensione dello stack di thread su. 0.5 MiB Necessario per le build di [Alpine Linux](https://wiki.alpinelinux.org/wiki/Main_Page). Altrimenti, viene utilizzata l'impostazione predefinita del sistema operativo. | | `BUILD_STATIC` | Booleano | OFF | Crea librerie ed eseguibili come [condivisi](https://en.wikipedia.org/wiki/Shared_library) (OFF) o [statici](https://en.wikipedia.org/wiki/Static_library) (ON). | | `ADD_MUCLIBC` | Booleano | OFF | Collegati a [uClibc](https://en.wikipedia.org/wiki/UClibc) anziché alla libreria C standard, che è una libreria standard C più piccola progettata per sistemi integrati. | | `OPEN_SRC_INSTALL_PREFIX` | Stringa | .. /open source/locale | Posizione in cui installare le dipendenze open source, se compilate dal codice sorgente. | **Bandiere per la compilazione incrociata** **Importante** Impostali se le architetture della CPU del computer di destinazione e quelle del computer host sono diverse. | CMake argomento | Tipo | Predefinita | Spiegazione | | --- | --- | --- | --- | | `BUILD_LOG4CPLUS_HOST` | Stringa | "" | Crea la log4cplus dipendenza per l'architettura della CPU specificata. Se non è impostato, log4cplus rileverà automaticamente e utilizzerà l'architettura della CPU della macchina host. | | `BUILD_OPENSSL_PLATFORM` | Stringa | "" | Crea la OpenSSL dipendenza per l'architettura CPU specificata. Se non è impostato, OpenSSL rileverà automaticamente e utilizzerà l'architettura della CPU della macchina host. | **Bandiere relative ai test** | CMake argomento | Tipo | Predefinita | Spiegazione | | --- | --- | --- | --- | | `BUILD_TEST` | Booleano | OFF | Costruisci i test unitari e di integrazione. Per eseguire tutti i test, esegui ./tst/producerTest dalla directory build. AWS Le credenziali sono necessarie per eseguire i test. | | `CODE_COVERAGE` | Booleano | OFF | Disponibile solo per i GNU/Clang compilatori. Abilita la raccolta della copertura del codice con [gcov](https://gcc.gnu.org/onlinedocs/gcc/Gcov.html) e la generazione di report. | | `COMPILER_WARNINGS` | Booleano | OFF | Disponibile solo per GNU/Clang i compilatori. Abilita tutti gli avvisi del compilatore. | | `ADDRESS_SANITIZER` | Booleano | OFF | Disponibile solo per GNU/Clang i compilatori. Costruisci con [AddressSanitizer](https://compiler-rt.llvm.org/). | | `MEMORY_SANITIZER` | Booleano | OFF | Disponibile solo per i GNU/Clang compilatori. Costruisci con [MemorySanitizer](https://compiler-rt.llvm.org/). | | `THREAD_SANITIZER` | Booleano | OFF | Disponibile solo per i GNU/Clang compilatori. Costruisci con [ThreadSanitizer](https://compiler-rt.llvm.org/). | | `UNDEFINED_BEHAVIOR_SANITIZER` | Booleano | OFF | Disponibile solo per i GNU/Clang compilatori. Costruisci con [UndefinedBehaviorSanitizer](https://compiler-rt.llvm.org/). | Per utilizzare questi CMake argomenti, passali come elenco di `-Dkey=value` coppie separate da spazi dopo il `cmake ..` comando. Esempio: ``` cmake .. -DBUILD_GSTREAMER_PLUGIN=ON -DBUILD_DEPENDENCIES=OFF -DALIGNED_MEMORY_MODEL=ON ``` CMake cercherà la toolchain del compilatore seguendo la variabile. `$PATH` Prima dell'esecuzione CMake, imposta le variabili `CC` e di `CXX` ambiente per impostare in modo esplicito la toolchain da utilizzare per la compilazione incrociata. # Scrivi ed esamina il codice In questa sezione di[Usa la libreria Producer C\$1\$1](producer-sdk-cpp.md), si esamina il codice nel test harness C\$1\$1 (`tst/ProducerTestFixture.h`e in altri file). Hai scaricato questo codice nella sezione precedente. L'esempio di C\$1\$1 **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) \$1 3 (minuti) \$1 60 (secondi al minuto) \$1 10000 (kb) \$1 1,2 (margine di deframmentazione) = 194,4** Mb \$1 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\$1AAC»). + Tipo di traccia (ad esempio, utilizzate il valore enum di MKV\$1TRACK\$1INFO\$1TYPE\$1AUDIO 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\$1\$1 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\$1\$1 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); ``` # Esegui e verifica il codice Per eseguire e verificare il codice di[Usa la libreria Producer C\$1\$1](producer-sdk-cpp.md), consulta le seguenti istruzioni specifiche del sistema operativo: + [Linux](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/linux.md) + [macOS](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/macos.md) + [Windows](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/windows.md) + [Sistema operativo Raspberry Pi](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/raspberry-pi.md) Puoi monitorare il traffico sul tuo stream guardando le metriche associate al tuo stream nella CloudWatch console Amazon, ad esempio`PutMedia.IncomingBytes`. # Usa il C\$1\$1 Producer SDK come plugin GStreamer [GStreamer](https://gstreamer.freedesktop.org/)è un popolare framework multimediale utilizzato da più fotocamere e sorgenti video per creare pipeline multimediali personalizzate combinando plugin modulari. Il plug-in Kinesis GStreamer Video Streams semplifica l'integrazione della GStreamer pipeline multimediale esistente con Kinesis Video Streams. Per informazioni sull'utilizzo del C\$1\$1 Producer SDK come plugin, consulta. GStreamer [Esempio: plugin SDK per GStreamer produttori di Kinesis Video Streams - kvssink](examples-gstreamer-plugin.md) # Usa il C\$1\$1 producer SDK come GStreamer plug-in in un contenitore Docker [GStreamer](https://gstreamer.freedesktop.org/)è un popolare framework multimediale utilizzato da più telecamere e sorgenti video per creare pipeline multimediali personalizzate combinando plug-in modulari. Il plug-in Kinesis GStreamer Video Streams semplifica l'integrazione della GStreamer pipeline multimediale esistente con Kinesis Video Streams. Inoltre, l'utilizzo di [Docker]() per creare la GStreamer pipeline standardizza l'ambiente operativo per Kinesis Video Streams, semplificando la creazione e l'esecuzione dell'applicazione. Per informazioni sull'utilizzo di C\$1\$1 Producer SDK come plug-in in un GStreamer contenitore Docker, consulta. [Esegui l' GStreamer elemento in un contenitore Docker](examples-gstreamer-plugin.md#examples-gstreamer-plugin-docker) # Usa la registrazione con C\$1\$1 Producer SDK La registrazione per le applicazioni C\$1\$1 Producer SDK viene configurata nel `kvs_log_configuration` file nella cartella. `kinesis-video-native-build` L'esempio seguente mostra la prima riga del file di configurazione predefinito, che configura l'applicazione per scrivere voci di livello `DEBUG` nella Console di gestione AWS: ``` log4cplus.rootLogger=DEBUG, KvsConsoleAppender ``` È possibile impostare il livello di logging su `INFO` per ottenere un log meno dettagliato. Per configurare l'applicazione in modo che scriva le voci di registro in un file di registro, aggiorna la prima riga del file nel modo seguente: ``` log4cplus.rootLogger=DEBUG, KvsConsoleAppender, KvsFileAppender ``` Ciò consente di configurare l'applicazione per scrivere voci di log nel file `kvs.log` nella cartella `kinesis-video-native-build/log`. Per modificare la posizione del file di log, aggiorna la riga seguente con il nuovo percorso: ``` log4cplus.appender.KvsFileAppender.File=./log/kvs.log ``` **Nota** Se il logging di livello `DEBUG` viene scritto in un file, il file di log può occupare rapidamente tutto lo spazio di storage disponibile nel dispositivo.