

本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 亚马逊 Kinesis Video Streams 示例
<a name="examples"></a>

以下代码示例演示了如何使用 Kinesis Video Streams API：

## 示例：向 Kinesis Video Streams 发送数据
<a name="examples-toc-producer"></a>
+ [示例：Kinesis Video Streams 制作人 GStreamer SDK 插件-kvssink](examples-gstreamer-plugin.md)：演示如何构建 Kinesis Video Streams 制作人软件开发工具包以 GStreamer 用作目标。
+ [在 Docker 容器中运行该 GStreamer 元素](examples-gstreamer-plugin.md#examples-gstreamer-plugin-docker)：演示如何使用预构建的 Docker 镜像将实时流协议 (RTSP) 视频从 IP 摄像机发送到 Kinesis Video Streams。
+ [示例：从 RTSP 来源进行流式传输](examples-rtsp.md): 演示如何构建自己的 Docker 镜像以及如何将 RTSP 视频从 IP 摄像机发送到 Kinesis Video Streams。
+ [示例：使用 PutMedia API 向 Kinesis Video Streams 发送数据](examples-putmedia.md)：演示如何使用 API 将已经采用容器格式 (MKV) 的数据发送到 Kinesis Video Streams [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)。[使用 Java 制作器库](producer-sdk-javaapi.md)

## 示例：从 Kinesis Video Streams 检索数据
<a name="examples-toc-consumer"></a>
+ [KinesisVideoExample](parser-library-write.md#parser-library-write-example)：演示如何使用 Kinesis Video Streams 解析器库解析和记录视频片段。
+ [示例：解析和渲染 Kinesis Video Streams 片段](examples-renderer.md)：演示如何使用和解析和渲染 Kinesis 视频流片段[JCodec](http://jcodec.org/)。[JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html)

## 示例：播放视频数据
<a name="examples-toc-playback"></a>
+ [示例：在 HTML 中使用 HLS 和 JavaScript](hls-playback.md#how-hls-ex1)：演示如何检索 Kinesis 视频流的 HLS 直播会话并在网页中播放。

## 先决条件
<a name="examples-prerequisites"></a>
+ 在示例代码中，您可以通过指定在凭据配置文件中设置的配置文件或在集成开发环境 (IDE) 的 Java 系统属性中提供凭据来提供凭据。 AWS 如果您还没有这样做，请先设置您的凭据。有关更多信息，请参阅[设置用于开发的 AWS 凭据和区域](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-credentials.html)。
+ 建议您使用 Java IDE 来查看和运行代码，例如下列项之一：
  + [Eclipse Java Neon](https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-jee-neon-3)
  + [JetBrains IntelliJ IDEA](https://www.jetbrains.com/idea/)

# 示例：Kinesis Video Streams 制作人 GStreamer SDK 插件-kvssink
<a name="examples-gstreamer-plugin"></a>

本主题介绍如何构建用作 GStreamer 插件的 Amazon Kinesis Video Streams 制作人软件开发工具包。

**Topics**
+ [下载、构建和配置 GStreamer 元素](#examples-gstreamer-plugin-download)
+ [运行 GStreamer 元素](#examples-gstreamer-plugin-run)
+ [GStreamer 启动命令示例](#examples-gstreamer-plugin-launch)
+ [在 Docker 容器中运行该 GStreamer 元素](#examples-gstreamer-plugin-docker)
+ [GStreamer 元素参数参考](examples-gstreamer-plugin-parameters.md)

[GStreamer](https://gstreamer.freedesktop.org/)是一种流行的媒体框架，可供多个摄像机和视频源使用，通过组合模块化插件来创建自定义媒体管道。Kinesis Video GStreamer Streams 插件简化了 GStreamer 现有媒体管道与 Kinesis Video Streams 的集成。集成后 GStreamer，您可以将来自网络摄像头或实时流媒体协议 (RTSP) 摄像机的视频流式传输到 Kinesis Video Streams，以便进行实时或以后的播放、存储和进一步分析。

该 GStreamer 插件通过将 Kinesis Video Streams 制作人 SDK GStreamer 提供的功能封装在接收器元素中，自动管理将视频流传输到 Kinesis Video Streams 的过程。`kvssink`该 GStreamer 框架提供了一个标准的托管环境，用于从摄像机或其他视频源等设备构建媒体流，用于进一步处理、渲染或存储。

 GStreamer 管道通常由源（摄像机）和接收器元素（用于渲染视频的播放器或用于离线检索的存储）之间的链接组成。在本示例中，您使用创建者开发工具包元素作为视频源（网络摄像机或 IP 摄像机）的*接收器*或媒体目标。然后，封装 SDK 的插件元素将视频流发送到 Kinesis Video Streams。

本主题介绍如何构建能够将视频源（例如网络摄像机或 RTSP 流）中的视频流式传输的 GStreamer 媒体管道，该视频通常通过中间编码阶段（使用 H.264 编码）连接到 Kinesis Video Streams。当您的视频流作为 Kinesis 视频流可用时，您可以使用[使用解析器库观看摄像机的输出](parser-library.md)对视频流进行进一步处理、播放、存储或分析。

![\[用于将视频从摄像机流式传输到服务的 GStreamer 媒体管道的功能视图。\]](http://docs.aws.amazon.com/zh_cn/kinesisvideostreams/latest/dg/images/gstreamer-pipeline.png)


## 下载、构建和配置 GStreamer 元素
<a name="examples-gstreamer-plugin-download"></a>

 GStreamer 插件示例包含在 Kinesis Video Streams Video Streams C\$1\$1 制作人 SDK 中。有关该开发工具包的先决条件和下载信息，请参阅[下载并配置 C\$1\$1 制作器库代码](producersdk-cpp-download.md)。

你可以在 macOS、Ubuntu、Raspberry Pi 或 Windows 上将制作 GStreamer 器 SDK 接收器构建为动态库。该 GStreamer 插件位于您的`build`目录中。要加载此插件，它必须位于您的插件中`GST_PLUGIN_PATH`。运行如下命令：

```
export GST_PLUGIN_PATH=`pwd`/build
```

**注意**  
在 macOS 上，只有在 Docker 容器 GStreamer 中运行时，才能从网络摄像机流式传输视频。在 macOS 上的 Docker 容器中，不支持对来自 USB 摄像机的视频进行流式处理。

## 运行 GStreamer 元素
<a name="examples-gstreamer-plugin-run"></a>

要使用 Kinesis Video Streams 制作人 SDK 元素作为接收器运行 GStreamer ，请使用命令`gst-launch-1.0`。使用适合 GStreamer 插件使用的上游元素。例如，对于 Linux 系统上的 v4l2 设备使用 [v4l2src](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page)，或对于 RTSP 设备使用 [rtspsrc](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page)。指定 `kvssink` 作为向创建者开发工具包发送视频的接收器（管道的最终目标）。

除了[提供凭证](https://docs.aws.amazon.com//kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html#credentials-to-kvssink)和[提供区域外，该](https://docs.aws.amazon.com//kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html#kvssink-region)`kvssink`元素还具有以下必需参数：
+ `stream-name`— 目的地 Kinesis Video Streams 的名称。

有关 `kvssink` 可选参数的信息，请参阅[GStreamer 元素参数参考](examples-gstreamer-plugin-parameters.md)。

有关 GStreamer 插件和参数的最新信息，请参阅[GStreamer 插件](https://gstreamer.freedesktop.org/documentation/plugins_doc.html?gi-language=c)。您也可以使用元素或插件名称`gst-inspect-1.0`后面加上 GStreamer 元素或插件的名称来打印其信息，并验证其是否在您的设备上可用：

```
gst-inspect-1.0 kvssink
```

如果构建`kvssink`失败或 GST\$1PLUGIN\$1PATH 设置不正确，则输出将如下所示：

```
No such element or plugin 'kvssink'
```

## GStreamer 启动命令示例
<a name="examples-gstreamer-plugin-launch"></a>

以下示例演示如何使用该`kvssink` GStreamer 插件从不同类型的设备流式传输视频。

### 示例 1：在 Ubuntu 上直播来自 RTSP 摄像头的视频
<a name="examples-gstreamer-plugin-launch-ex1"></a>

[以下命令使用 rtspsr GStreamer c 插件在 Ubuntu 上创建一个管道，该管道从网络 RTSP 摄像机进行直播：](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html?gi-language=c) GStreamer 

```
gst-launch-1.0 -v rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! h264parse ! kvssink stream-name="YourStreamName" storage-size=128
```

### 示例 2：在 Ubuntu 上对来自 USB 摄像头的视频进行编码和流式传输
<a name="examples-gstreamer-plugin-launch-ex2"></a>

以下命令在 Ubuntu 上创建一个 GStreamer 管道，该管道以 H.264 格式对来自 USB 摄像机的直播进行编码，然后将其流式传输到 Kinesis Video Streams。此示例使用 [v4l2src 插件](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page) GStreamer 。

```
gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! x264enc  bframes=0 key-int-max=45 bitrate=500 ! video/x-h264,stream-format=avc,alignment=au,profile=baseline ! kvssink stream-name="YourStreamName" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```

### 示例 3：在 Ubuntu 上流式传输来自 USB 摄像头的预编码视频
<a name="examples-gstreamer-plugin-launch-ex3"></a>

以下命令在 Ubuntu 上创建了一个 GStreamer 管道，该管道将摄像机已经以 H.264 格式编码的视频流式传输到 Kinesis Video Streams。此示例使用 [v4l2src 插件](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page) GStreamer 。

```
gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! h264parse ! video/x-h264,stream-format=avc,alignment=au ! kvssink stream-name="plugin" storage-size=512 access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```

### 示例 4：在 macOS 上流式传输来自网络摄像机的视频
<a name="examples-gstreamer-plugin-launch-ex4"></a>

以下命令在 macOS 上创建一个 GStreamer 管道，该管道通过网络摄像机将视频流式传输到 Kinesis Video Streams。此示例使用 rt [spsrc 插件](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) GStreamer 。

```
gst-launch-1.0 rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! h264parse ! video/x-h264, format=avc,alignment=au ! kvssink stream-name="YourStreamName" storage-size=512  access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```

### 示例 5：在 Windows 上流式传输来自网络摄像机的视频
<a name="examples-gstreamer-plugin-launch-ex5"></a>

以下命令在 Windows 上创建了一个 GStreamer 管道，该管道将视频从网络摄像机流式传输到 Kinesis Video Streams。此示例使用 rt [spsrc 插件](https://gstreamer.freedesktop.org/documentation/rtsp/rtspsrc.html#rtspsrc-page) GStreamer 。

```
gst-launch-1.0 rtspsrc location="rtsp://YourCameraRtspUrl" short-header=TRUE ! rtph264depay ! video/x-h264, format=avc,alignment=au ! kvssink stream-name="YourStreamName" storage-size=512  access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```

### 示例 6：在 Raspberry Pi 上直播来自摄像机的视频
<a name="examples-gstreamer-plugin-launch-ex6"></a>

以下命令在 Raspberry Pi 上创建了一个将视频流式传输到 Kinesis Video Streams 的 GStreamer 管道。此示例使用 [v4l2src 插件](https://gstreamer.freedesktop.org/documentation/video4linux2/v4l2src.html?gi-language=c#v4l2src-page) GStreamer 。

```
gst-launch-1.0 v4l2src do-timestamp=TRUE device=/dev/video0 ! videoconvert ! video/x-raw,format=I420,width=640,height=480,framerate=30/1 ! omxh264enc control-rate=1 target-bitrate=5120000 periodicity-idr=45 inline-header=FALSE ! h264parse ! video/x-h264,stream-format=avc,alignment=au,width=640,height=480,framerate=30/1,profile=baseline ! kvssink stream-name="YourStreamName" access-key="YourAccessKey" secret-key="YourSecretKey" aws-region="YourAWSRegion"
```

### 示例 7：在 Raspberry Pi 和 Ubuntu 中同时直播音频和视频
<a name="examples-gstreamer-plugin-launch-ex7"></a>

了解在 Raspberry-PI 和 Ubuntu 中如何[运行 gst-launch-1.0 命令开始对音频和视频进行流式处理](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/linux.md#running-the-gst-launch-10-command-to-start-streaming-both-audio-and-video-in-raspberry-pi-and-ubuntu)。

### 示例 8：在 macOS 中流式传输来自设备源的音频和视频
<a name="examples-gstreamer-plugin-launch-ex8"></a>

了解在 MacOS 中如何[运行 gst-launch-1.0 命令开始对音频和视频进行流式处理](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/macos.md#running-the-gst-launch-10-command-to-start-streaming-both-audio-and-raw-video-in-mac-os)。

### 示例 9：上传同时包含音频和视频的 MKV 文件
<a name="examples-gstreamer-plugin-launch-ex9"></a>

了解如何[运行 gst-launch-1.0 命令来上传包含音频和视频的 MKV 文件](https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-cpp/blob/master/docs/windows.md#running-the-gst-launch-10-command-to-upload-mkv-file-that-contains-both-audio-and-video)。你需要一个包含 h.264 和 AAC 编码媒体的 MKV 测试文件。

## 在 Docker 容器中运行该 GStreamer 元素
<a name="examples-gstreamer-plugin-docker"></a>

Docker 是一个使用容器来开发、部署和运行应用程序的平台。使用 Docker 创建 GStreamer 管道可以标准化 Kinesis Video Streams 的操作环境，从而简化了应用程序的构建和使用。

要安装和配置 Docker，请参阅以下内容：
+ [Docker 下载说明](https://docs.docker.com/engine/install/)
+ [开始使用 Docker](https://docs.docker.com/guides/getting-started/)

安装 Docker 后，你可以使用下面`docker pull`提供的命令之一从亚马逊弹性容器注册表下载 Kinesis Video Streams C\$1\$1 Producer SDK（ GStreamer 和插件）。

要将 Kinesis Video Streams 制作器 SDK 元素作为 Docker 容器中的接收器运行 GStreamer ，请执行以下操作：

**Topics**
+ [对你的 Docker 客户端进行身份验证](#examples-gstreamer-plugin-docker-authenticate)
+ [下载用于 Ubuntu、macOS、Windows 或 Raspberry Pi 的 Docker 映像](#examples-gstreamer-plugin-docker-download)
+ [运行 Docker 镜像](#examples-gstreamer-plugin-docker-run)

### 对你的 Docker 客户端进行身份验证
<a name="examples-gstreamer-plugin-docker-authenticate"></a>

将您的 Docker 客户端验证到要从中提取镜像的 Amazon ECR 注册表。您必须为使用的每个注册表获取身份验证令牌。代币的有效期为 12 小时。有关更多信息，请参阅 *Amazon Elastic Container Registry 用户指南*中的[注册表身份验证](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth)。

**Example 向 Amazon ECR 进行身份验证**  
要使用 Amazon ECR 进行身份验证，请复制并粘贴以下命令，如图所示。  

```
sudo aws ecr get-login-password --region us-west-2 | docker login -u AWS --password-stdin https://546150905175.dkr.ecr.us-west-2.amazonaws.com
```
如果成功，输出将打印 `Login Succeeded`。

### 下载用于 Ubuntu、macOS、Windows 或 Raspberry Pi 的 Docker 映像
<a name="examples-gstreamer-plugin-docker-download"></a>

根据您的操作系统，使用以下命令之一将 Docker 映像下载到您的 Docker 环境：

#### 下载用于 Ubuntu 的 Docker 映像
<a name="examples-gstreamer-plugin-docker-download-ubuntu"></a>

```
sudo docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux:latest
```

#### 下载用于 macOS 的 Docker 映像
<a name="examples-gstreamer-plugin-docker-download-macos"></a>

```
docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux:latest
```

#### 下载用于 Windows 的 Docker 映像
<a name="examples-gstreamer-plugin-docker-download-windows"></a>

```
docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-windows:latest
```

#### 下载用于 Raspberry Pi 的 Docker 映像
<a name="examples-gstreamer-plugin-docker-download-rpi"></a>

```
sudo docker pull 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-raspberry-pi:latest
```

要验证是否已成功添加镜像，请使用以下命令：

```
docker images
```

### 运行 Docker 镜像
<a name="examples-gstreamer-plugin-docker-run"></a>

根据您的操作系统，使用以下命令之一运行 Docker 映像：

#### 在 Ubuntu 上运行 Docker 镜像
<a name="examples-gstreamer-plugin-docker-run-ubuntu"></a>

```
sudo docker run -it --network="host" --device=/dev/video0 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux /bin/bash
```

#### 在 macOS 上运行 Docker 镜像
<a name="examples-gstreamer-plugin-docker-run-macos"></a>

```
sudo docker run -it --network="host" 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-amazon-linux /bin/bash
```

#### 在 Windows 上运行 Docker 镜像
<a name="examples-gstreamer-plugin-docker-run-windows"></a>

```
docker run -it 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-windows AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY RTSP_URL STREAM_NAME
```

#### 在树莓派上运行 Docker 镜像
<a name="examples-gstreamer-plugin-docker-run-rpi"></a>

```
sudo docker run -it --device=/dev/video0 --device=/dev/vchiq -v /opt/vc:/opt/vc 546150905175.dkr.ecr.us-west-2.amazonaws.com/kinesis-video-producer-sdk-cpp-raspberry-pi /bin/bash
```

Docker 启动容器并显示命令提示符，供您在容器中使用命令。

在该容器中，使用以下命令设置环境变量：

```
export LD_LIBRARY_PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
export PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/bin:$PATH
export GST_PLUGIN_PATH=/opt/awssdk/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$GST_PLUGIN_PATH
```

开始`kvssink`使用流式传输`gst-launch-1.0`以运行适合您的设备和视频源的管道。有关管道的示例，请参见[GStreamer 启动命令示例](#examples-gstreamer-plugin-launch)。

# GStreamer 元素参数参考
<a name="examples-gstreamer-plugin-parameters"></a>

要向 Amazon Kinesis Video Streams Video Streams 制作人 C\$1\$1 SDK 发送视频，请*将*视频`kvssink`指定为管道的接收方或最终目的地。此参考提供了有关 `kvssink` 必需参数和可选参数的信息。有关更多信息，请参阅 [示例：Kinesis Video Streams 制作人 GStreamer SDK 插件-kvssink](examples-gstreamer-plugin.md)。

**主题**
+ [向提供凭证 `kvssink`](#credentials-to-kvssink)
+ [提供一个区域给 `kvssink`](#kvssink-region)
+ [`kvssink`可选参数](#kvssink-optional-parameters)

## 向提供凭证 `kvssink`
<a name="credentials-to-kvssink"></a>

要允许`kvssink` GStreamer 元素向其发出请求 AWS，请提供 AWS 凭证供其在调用 Amazon Kinesis Video Streams 服务时使用。凭证提供商链按以下顺序查找证书：

### 1。 AWS IoT 证书
<a name="collapsible-section-1"></a>

要设置 AWS IoT 凭证，请参阅[使用控制对 Kinesis Video Streams 资源的访问权限 AWS IoT](how-iot.md)。

`iot-credentials`参数值必须以逗号分隔`iot-certificate,`的以下 *key* = *value* 对开头，后面是逗号分隔的列表。


****  

| Key | 必需 | 描述 | 
| --- | --- | --- | 
| ca-path | 是 | 用于通过 TLS 与后端服务建立信任的 CA 证书的文件路径。 

**Example**  
**示例**：` /file/path/to/certificate.pem` | 
| cert-path | 是 | X.509 证书的文件路径。 

**Example**  
**示例**：`/file/path/to/certificateID-certificate.pem.crt` | 
| endpoint | 是 | 您 AWS 账户的 AWS IoT Core 凭证终端节点提供商终端节点。请参阅《[AWS IoT 开发人员指南》](https://docs.aws.amazon.com//iot/latest/developerguide/authorizing-direct-aws.html)。 

**Example**  
**示例**：`credential-account-specific-prefix.credentials.iot.aws-region.amazonaws.com` | 
| key-path | 是 | key pair 中使用的私 public/private 钥的文件路径。 

**Example**  
**示例**：`/file/path/to/certificateID-private.pem.key` | 
| role-aliases | 是 | 指向连接时要使用 AWS 的 IAM 角色的角色别名的名称 AWS IoT Core。 

**Example**  
**示例**：`KvsCameraIoTRoleAlias` | 
| iot-thing-name | 否 | `iot-thing-name` 是可选项。如果`iot-thing-name`未提供，则使用`stream-name`参数值。 

**Example**  
**示例**：`kvs_example_camera` | 

**Example**  
**示例**：  

```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" iot-certificate="iot-certificate,endpoint=credential-account-specific-prefix.credentials.iot.aws-region.amazonaws.com,cert-path=certificateID-certificate.pem.crt,key-path=certificateID-private.pem.key,ca-path=certificate.pem,role-aliases=YourRoleAlias,iot-thing-name=YourThingName"
```

### 2. 环境变量
<a name="collapsible-section-2"></a>

要`kvssink`使用来自环境的凭证，请设置以下环境变量：


****  

| 环境变量名 | 必需 | 描述 | 
| --- | --- | --- | 
| AWS\$1ACCESS\$1KEY\$1ID | 是 | 用于 AWS 访问亚马逊 Kinesis Video Streams 的访问密钥。 | 
| AWS\$1SECRET\$1ACCESS\$1KEY | 是 | 与访问 AWS 密钥关联的密钥。 | 
| AWS\$1SESSION\$1TOKEN | 否 | 如果您直接使用 AWS STS 操作中的临时安全证书，则指定所需的会话令牌值。 | 

设置环境变量会更改使用的值，直到 Shell 会话结束或直到您将该变量设置为其他值。要使变量在 future 会话中保持不变，请在 shell 的启动脚本中对其进行设置。

### 3。 `access-key`，`secret-key`参数
<a name="collapsible-section-3"></a>

要直接将凭据指定为`kvssink`参数，请设置以下参数：


****  

| `kvssink`参数名 | 必需 | 描述 | 
| --- | --- | --- | 
| access-key | 是 | 用于 AWS 访问亚马逊 Kinesis Video Streams 的访问密钥。 | 
| secret-key | 是 | 与访问 AWS 密钥关联的密钥。 | 
| session-token | 否 | 如果您直接使用 AWS STS 操作中的临时安全证书，则指定所需的会话令牌值。 | 

**Example**  
**使用静态凭证：**  

```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" access-key="AKIDEXAMPLE" secret-key="SKEXAMPLE"
```

**Example**  
**使用临时证书：**  

```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" access-key="AKIDEXAMPLE" secret-key="SKEXAMPLE" session-token="STEXAMPLE"
```

### 4. 凭证文件
<a name="collapsible-section-4"></a>

**重要**  
如果您选择了前面的方法之一，则无法使用该`credential-path``kvssink`参数。


****  

| `kvssink`参数名 | 必需 | 描述 | 
| --- | --- | --- | 
| credential-path | 是 | 包含特定格式凭据的文本文件的路径。 | 

文本文件必须包含以下格式之一的凭据：
+ 全权证书 *YourAccessKey* *YourSecretKey*
+ 全权证书 *YourAccessKey* *Expiration* *YourSecretKey* *SessionToken*

**Example**  
**示例：**您的`credentials.txt`文件位于`/home/ubuntu`并包含以下内容：  
`CREDENTIALS AKIDEXAMPLE 2023-08-10T22:43:00Z SKEXAMPLE STEXAMPLE`  
要在中使用它`kvssink`，请键入：  

```
gst-launch-1.0 -v ... ! kvssink stream-name="YourStream" aws-region="YourRegion" credential-path="/home/ubuntu/credentials.txt" 
```
将来的到期时间应至少为 5 \$1 30 \$1 3 = **38** 秒。宽限期定义为中的`IOT_CREDENTIAL_FETCH_GRACE_PERIOD`变量[https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/Common/IotCredentialProvider.h](https://github.com/awslabs/amazon-kinesis-video-streams-producer-c/blob/master/src/source/Common/IotCredentialProvider.h)。如果您启动时凭证过于接近到期时间`kvssink`，则会收到错误代码`0x52000049 - STATUS_INVALID_TOKEN_EXPIRATION`。
`kvssink`不会修改凭据文件。如果您使用的是临时证书，则证书文件必须在到期时间减去宽限期之前由外部来源更新。

## 提供一个区域给 `kvssink`
<a name="kvssink-region"></a>

以下是区域查询顺序：

1. `AWS_DEFAULT_REGION`首先审查环境变量。如果已设置，则使用该区域来配置客户端。

1. `aws-region`接下来将查看参数。如果已设置，则使用该区域来配置客户端。

1. 如果前面的方法均未使用，`kvssink`则默认为`us-west-2`。

## `kvssink`可选参数
<a name="kvssink-optional-parameters"></a>

`kvssink` 元素具有以下可选参数。有关这些参数的更多信息，请参阅 [Kinesis 视频流结构](producer-reference-structures-stream.md)。


****  

| 参数 | 说明 | 单位/类型 | 默认 | 
| --- | --- | --- | --- | 
| stream-name  | 目标 Amazon Kinesis 视频流的名称。 如果未指定直播名称，则将使用默认的直播名称：“DEFAULT\$1STREAM”。如果使用该默认名称的直播尚不存在，则会创建该流。  |  |  | 
| absolute-fragment-times | 是否使用绝对片段时间。 | 布尔值 | true | 
| access-key | 用于 AWS 访问 Kinesis Video Streams 的访问密钥。 您必须设置 AWS 凭据或提供此参数。要提供此信息，请键入以下内容： <pre>export AWS_ACCESS_KEY_ID=</pre> |  |  | 
| avg-bandwidth-bps | 流的预期平均带宽。 | 每秒位元数 | 4194304 | 
| aws-region |  AWS 区域 要使用的。  您也可以为该区域提供`AWS_DEFAULT_REGION`环境变量。如果同时设置了环境变量和 kvssink 参数，则环境变量优先。   `us-west-2`如果未另行指定，则该区域将默认为。   | 字符串 | "us-west-2" | 
| buffer-duration | 流缓冲持续时间。 | 秒 | 120 | 
| codec-id | 流的编解码器 ID。 | 字符串 | "V\$1MPEG4/ISO/AVC" | 
| connection-staleness | 之后调用直播陈旧回调的时间。 | 秒 | 60 | 
| content-type | 流的内容类型。 | 字符串 | "video/h264" | 
| fragment-acks | 是否使用片段 ACKs。 | 布尔值 | true | 
| fragment-duration | 所需的片段持续时间。 | 毫秒 | 2000 | 
| framerate | 预期的帧率。 | 每秒帧数 | 25 | 
| frame-timecodes | 是否使用帧时间码或者使用当前时间回调生成时间戳。 | 布尔值 | true | 
| key-frame-fragmentation | 是否在关键帧上生成片段。 | 布尔值 | true | 
| log-config | 日志配置路径。 | 字符串 | "../kvs\$1log\$1configuration" | 
| max-latency | 流的最大延迟。 | 秒 | 60 | 
| recalculate-metrics | 是否重新计算指标。 | 布尔值 | true | 
| replay-duration | 启用重新启动时，在出错时回滚当前阅读器以重放的持续时间。 | 秒 | 40 | 
| restart-on-error | 发生错误时是否重新启动。 | 布尔值 | true | 
| retention-period | 保留流的时间长度。 | Hours | 2 | 
| rotation-period | 密钥轮换周期。有关更多信息，请参阅[轮换 AWS KMS 密钥](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html)。 | 秒 | 3600 | 
| secret-key |  用于访问 Kinesis Video Streams 的 AWS 密钥。 您必须设置 AWS 凭据或提供此参数。 <pre>export AWS_SECRET_ACCESS_KEY=</pre>  |  |  | 
| session-token | 如果您直接使用 AWS STS 操作中的临时安全证书，则指定所需的会话令牌值。 |  |  | 
| storage-size | 以兆字节 (MiB) 为单位的设备存储大小。有关配置设备存储的信息，请参阅[StorageInfo](producer-reference-structures-producer.md#producer-reference-structures-producer-storageinfo)。 | 兆字节 (MiB) | 128 | 
| streaming-type | 流式处理类型。有效值包括：[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html) | 枚举 GstKvsSinkStreamingType | 0：实时 | 
| timecode-scale | MKV 时间码标度。 | 毫秒 | 1 | 
| track-name | MKV 音轨名称。 | 字符串 | "kinesis\$1video" | 
| iot-certificate | AWS IoT 要在`kvssink`元素中使用的证书。 `iot-certificate`接受以下键和值：  `iot-thing-name`是**可选**的。如果`iot-thing-name`未提供，则使用`stream-name`参数值。  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/kinesisvideostreams/latest/dg/examples-gstreamer-plugin-parameters.html) | 字符串 | 无 | 

# 示例：使用 PutMedia API 向 Kinesis Video Streams 发送数据
<a name="examples-putmedia"></a>

此示例演示了如何使用 [PutMedia](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html)API。它显示了如何发送已经是容器格式 (MKV) 的数据。如果您的数据在发送之前必须汇编成容器格式（例如，如果您要将摄像机视频数据组合成帧），请参阅[上传到 Kinesis Video Streams](producer-sdk.md)。

**注意**  
该`PutMedia`操作仅在 C\$1\$1 和 Java 中可用 SDKs。这是因为连接、数据流和确认采用全双工管理。其他语言不支持它。

**Topics**
+ [下载并配置代码](#examples-putmedia-download)
+ [编写并检查代码](#examples-putmedia-write)
+ [运行并验证代码](#examples-putmedia-run)

## 下载并配置代码
<a name="examples-putmedia-download"></a>

按照以下步骤下载 Java 示例代码，将项目导入 Java IDE，配置库位置，然后配置代码以使用您的 AWS 凭据。

1. 创建目录并从 GitHub存储库中克隆示例源代码。`PutMedia` 示例是 [Java](producer-sdk-javaapi.md) 的一部分。

   ```
   git clone https://github.com/awslabs/amazon-kinesis-video-streams-producer-sdk-java
   ```

1. 打开你正在使用的 Java IDE（例如 Eclip [se 或 Intelli](https://www.eclipse.org/) [J ID](https://www.jetbrains.com/idea/) EA），然后导入你下载的 Apache Maven 项目：
   + **在 Eclipse 中：**依次选择 **File** (文件)、**Import** (导入)、**Maven** 和 **Existing Maven Projects** (现有的 Maven 项目)，然后导航到下载的程序包的根目录。选择 `pom.xml` 文件。
   + **在 IntelliJ Idea 中：**选择 **Import**。导航到下载的程序包的根目录中的 `pom.xml` 文件。

    有关更多信息，请参阅相关的 IDE 文档。

1. 更新项目，以便 IDE 可以发现您导入的库。
   + 对于 IntelliJ IDEA，请执行下列操作之一：

     1. 打开项目的 **lib** 目录的上下文菜单 (右键单击)，选择 **Add as library**。

     1. 选择 “**文件**”，然后选择 “**项目结构**”。

     1. 在 **Project Settings** 下，选择 **Modules**。

     1. 在 **Sources (源)** 选项卡中，将 **Language Level (语言级别)** 设置为 **7** 或更大值。
   + 对于 Eclipse，执行以下操作：

     1. 打开项目的上下文菜单 (右键单击)，并依次选择 **Properties**、**Java Build Path** 和 **Source**。然后执行以下操作：

        1. 在 **Source** 选项卡中，双击 **Native library location**。

        1. 在 **Native Library Folder Configuration** 向导中，选择 **Workspace**。

        1. 在 **Native Library Folder** 选择项中，选择项目中的 **lib** 目录。

     1. 打开项目的上下文菜单 (右键单击)，选择 **Properties**。然后执行以下操作：

        1. 在 **Libraries** 选项卡上，选择 **Add Jars**。

        1. 在 **JAR 选择** 向导中，选择项目的 `lib` 目录中的所有 .jar。

## 编写并检查代码
<a name="examples-putmedia-write"></a>

`PutMedia` API 示例 (`PutMediaDemo`) 显示以下编码模式：

**Topics**
+ [创建 PutMediaClient](#producersdk-javaapi-writecode-putmediaapi-putmediaclient)
+ [对媒体进行流式处理并暂停线程](#producersdk-javaapi-writecode-putmediaapi-run)

此部分中的代码示例来自 `PutMediaDemo` 类。

### 创建 PutMediaClient
<a name="producersdk-javaapi-writecode-putmediaapi-putmediaclient"></a>

创建`PutMediaClient`对象需要以下参数：
+ `PutMedia` 终端节点的 URI。
+ 一个 `InputStream`，指向要流式处理的 MKV 文件。
+ 流名称。此示例使用已在 [使用 Java 制作器库](producer-sdk-javaapi.md) (`my-stream`) 中创建的流。要使用其他流，请更改以下参数：

  ```
  private static final String STREAM_NAME="my-stream";
  ```
**注意**  
`PutMedia`API 示例未创建直播。你必须使用测试应用程序[使用 Java 制作器库](producer-sdk-javaapi.md)、Kinesis Video Streams 控制台或 AWS CLI。
+ 当前时间戳。
+ 时间码类型。此示例使用 `RELATIVE`，指示时间戳相对于容器的开始时间。
+ 一个 `AWSKinesisVideoV4Signer` 对象，验证收到的数据包是否由授权发件人发送。
+ 最大上游带宽 (以 Kbps 为单位)。
+ 一个 `AckConsumer` 对象，用于接收“数据包已接收确认”。

以下代码创建 `PutMediaClient` 对象：

```
/* actually URI to send PutMedia request */
final URI uri = URI.create(KINESIS_VIDEO_DATA_ENDPOINT + PUT_MEDIA_API);

/* input stream for sample MKV file */
final InputStream inputStream = new FileInputStream(MKV_FILE_PATH);

/* use a latch for main thread to wait for response to complete */
final CountDownLatch latch = new CountDownLatch(1);

/* a consumer for PutMedia ACK events */
final AckConsumer ackConsumer = new AckConsumer(latch);

/* client configuration used for AWS SigV4 signer */
final ClientConfiguration configuration = getClientConfiguration(uri);

/* PutMedia client */
final PutMediaClient client = PutMediaClient.builder()
        .putMediaDestinationUri(uri)
        .mkvStream(inputStream)
        .streamName(STREAM_NAME)
        .timestamp(System.currentTimeMillis())
        .fragmentTimeCodeType("RELATIVE")
        .signWith(getKinesisVideoSigner(configuration))
        .upstreamKbps(MAX_BANDWIDTH_KBPS)
        .receiveAcks(ackConsumer)
        .build();
```

### 对媒体进行流式处理并暂停线程
<a name="producersdk-javaapi-writecode-putmediaapi-run"></a>

在创建客户端后，此示例使用 `putMediaInBackground` 开始异步流式处理。随后，主线程将暂停并显示 `latch.await`，直到 `AckConsumer` 返回，此时客户端已关闭。

```
 /* start streaming video in a background thread */
            client.putMediaInBackground();

            /* wait for request/response to complete */
            latch.await();

            /* close the client */
            client.close();
```

## 运行并验证代码
<a name="examples-putmedia-run"></a>

若要运行 `PutMedia` API 示例，请执行以下操作：

1. 在 Kinesis Video Streams 控制台`my-stream`中或使用 AWS CLI创建名为的直播。

1. 将工作目录更改为 Java 创建者开发工具包目录：

   ```
   cd /<YOUR_FOLDER_PATH_WHERE_SDK_IS_DOWNLOADED>/amazon-kinesis-video-streams-producer-sdk-java/
   ```

1. 编译 Java 开发工具包演示应用程序：

   ```
   mvn package
   ```

1. 在 `/tmp` 目录中创建临时文件名：

   ```
   jar_files=$(mktemp)
   ```

1. 创建从本地存储库到文件的依赖项的类路径字符串：

   ```
   mvn -Dmdep.outputFile=$jar_files dependency:build-classpath
   ```

1. 将 `LD_LIBRARY_PATH` 环境变量的值设置如下：

   ```
   export LD_LIBRARY_PATH=/<YOUR_FOLDER_PATH_WHERE_SDK_IS_DOWNLOADED>/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build/downloads/local/lib:$LD_LIBRARY_PATH
   $ classpath_values=$(cat $jar_files)
   ```

1. 按如下所示从命令行运行演示，并提供您的 AWS 凭据：

   ```
   java -classpath target/kinesisvideo-java-demo-1.0-SNAPSHOT.jar:$classpath_values -Daws.accessKeyId=${ACCESS_KEY} -Daws.secretKey=${SECRET_KEY} -Djava.library.path=/opt/amazon-kinesis-video-streams-producer-sdk-cpp/kinesis-video-native-build com.amazonaws.kinesisvideo.demoapp.DemoAppMain
   ```

1. 打开 [Kinesis Video Stream](https://console.aws.amazon.com//kinesisvideo/home/) s 控制台，然后在 “**管理直播” 页面上**选择您的直播。该视频将在 **Video Preview** 窗格中播放。

# 示例：从 RTSP 来源进行流式传输
<a name="examples-rtsp"></a>

[C\$1\$1](producer-sdk-cpp.md)包含连接到实时流协议 (RTSP) 网络摄像机的 [Docker](https://www.docker.com/) 容器的定义。使用 Docker 可以标准化 Kinesis Video Streams 的操作环境，从而简化应用程序的构建和使用。

以下过程演示如何设置和使用此 RTSP 演示应用程序。

**Topics**
+ [教程视频](#rtsp-video)
+ [先决条件](#examples-rtsp-prerequisites)
+ [构建 Docker 映像。](#examples-rtsp-build)
+ [运行 RTSP 示例应用程序](#examples-rtsp-procedure)

## 教程视频
<a name="rtsp-video"></a>

此视频展示了如何设置 Raspberry Pi 以将 RTSP 提要发送到 AWS 云端和 Amazon Kinesis Video Streams。这是一个 end-to-end演示。

[![AWS Videos](http://img.youtube.com/vi/YoOYTCD_v3Q?si=ajdNXZpRhNnpAOKk/0.jpg)](http://www.youtube.com/watch?v=YoOYTCD_v3Q?si=ajdNXZpRhNnpAOKk)


本视频演示了如何从源中捕获图像以使用计算机视觉和 Amazon Rekognition 来处理图像和发送警报。




## 先决条件
<a name="examples-rtsp-prerequisites"></a>

要运行 Kinesis Video Streams RTSP 示例应用程序，必须具备以下条件：
+ **Docker：**有关安装和使用 Docker 的信息，请参阅以下链接：
  + [Docker 下载说明](https://docs.docker.com/desktop/)
  + [开始使用 Docker](https://docs.docker.com/guides/getting-started/)
+ **RTSP 网络摄像机源：**有关推荐摄像机的信息，请参阅[系统要求](system-requirements.md)。

## 构建 Docker 映像。
<a name="examples-rtsp-build"></a>

首先，构建演示应用程序将在其中运行的 Docker 镜像。

1. 克隆 Amazon Kinesis Video Streams 演示存储库。

   ```
   git clone https://github.com/aws-samples/amazon-kinesis-video-streams-demos.git
   ```

1. 切换到包含 Dockerfile 的目录。在本例中，它是 [docker-](https://github.com/aws-samples/amazon-kinesis-video-streams-demos/blob/master/producer-cpp/docker-rtsp/) rtsp 目录。

   ```
   cd amazon-kinesis-video-streams-demos/producer-cpp/docker-rtsp/
   ```

1. 使用以下命令构建 Docker 镜像。此命令创建镜像并将其标记为 rtspdockertest。

   ```
   docker build -t rtspdockertest .
   ```

1. 运行`docker images`并搜索标记为的图像 ID `rtspdockertest`。

   例如，在下面的示例输出中，`IMAGE ID`是`54f0d65f69b2`。

   ```
   REPOSITORY        TAG       IMAGE ID        CREATED           PLATFORM       SIZE         BLOB SIZE
   rtspdockertest    latest    54f0d65f69b2    10 minutes ago    linux/arm64    653.1 MiB    292.4 MiB
   ```

   稍后您将需要这个。

## 运行 RTSP 示例应用程序
<a name="examples-rtsp-procedure"></a>

您可以从 Docker 容器内部或外部运行 RTSP 示例应用程序。请按照以下相应说明进行操作。

**Topics**
+ [在 Docker 容器中](#examples-rtsp-within)
+ [在 Docker 容器外面](#examples-rtsp-outside)

### 在 Docker 容器中
<a name="examples-rtsp-within"></a>

**运行 RTSP 示例应用程序**

1. 使用以下命令启动 Amazon Kinesis Video Streams Docker 容器：

   ```
   docker run -it YourImageId /bin/bash
   ```

1. 要启动示例应用程序，请提供您的 AWS 证书、Amazon Kinesis 视频流的名称以及 RTSP 网络摄像机的网址。
**重要**  
如果您使用的是临时证书，则还需要提供您的`AWS_SESSION_TOKEN`。参见下面的第二个示例。

   ```
   export AWS_ACCESS_KEY_ID=YourAccessKeyId
   export AWS_SECRET_ACCESS_KEY=YourSecretKeyId
   export AWS_DEFAULT_REGION=YourAWSRegion
   ./kvs_gstreamer_sample YourStreamName YourRtspUrl
   ```

   **临时证书：**

   ```
   export AWS_ACCESS_KEY_ID=YourAccessKeyId
   export AWS_SECRET_ACCESS_KEY=YourSecretKeyId
   export AWS_SESSION_TOKEN=YourSessionToken
   export AWS_DEFAULT_REGION=YourAWSRegion
   ./kvs_gstreamer_sample YourStreamName YourRtspUrl
   ```

1. 登录 AWS 管理控制台 并打开 [Kinesis Video Streams](https://console.aws.amazon.com//kinesisvideo/home/) 控制台。

   观看直播。

1. 要退出 Docker 容器，请关闭终端窗口或键入`exit`。



### 在 Docker 容器外面
<a name="examples-rtsp-outside"></a>

在 Docker 容器**外**部，使用以下命令：

```
docker run -it YourImageId /bin/bash -c "export AWS_ACCESS_KEY_ID=YourAccessKeyId; export AWS_SECRET_ACCESS_KEY=YourSecretKeyId; export AWS_SESSION_TOKEN=YourSessionToken; export AWS_DEFAULT_REGION=Your AWS Region; ./kvs_gstreamer_sample YourStreamName YourRtspUrl"
```

# 示例：解析和渲染 Kinesis Video Streams 片段
<a name="examples-renderer"></a>

[使用解析器库进行直播](parser-library.md)包含一个名为的演示应用程序`KinesisVideoRendererExample`，用于演示解析和渲染 Amazon Kinesis 视频流片段。该示例用于[JCodec](http://jcodec.org/)解码使用应用程序摄取的 H.264 编码帧。[示例：Kinesis Video Streams 制作人 GStreamer SDK 插件-kvssink](examples-gstreamer-plugin.md)使用对帧进行解码后 JCodec，使用[JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html)渲染可见图像。

该示例说明了如何执行以下操作：
+ 使用 `GetMedia` API 从 Kinesis 视频流中检索帧并渲染该视频流以供观看。
+ 在自定义应用程序中查看直播的视频内容，而不是使用 Kinesis Video Streams 控制台。

您还可以使用此示例中的类来查看未编码为 H.264 的 Kinesis 视频流内容，例如在显示之前不需要解码的 JPEG 文件流。

以下过程说明了如何设置和使用渲染器演示应用程序。

## 先决条件
<a name="examples-renderer-prerequisites"></a>

要检查和使用渲染器示例库，您必须满足以下条件：
+ 亚马逊 Web Services (AWS) 账户。如果你还没有 AWS 账户，请参阅 [Kinesis Video Streams 入门](https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/getting-started.html)。
+ [Java 集成开发环境 (IDE)，例如 E [clipse Java Neon 或 IntelliJ I JetBrains d](https://www.eclipse.org/downloads/packages/release/neon/3/eclipse-jee-neon-3) ea。](https://www.jetbrains.com/idea/download/)

## 运行渲染器示例
<a name="examples-renderer-procedure"></a>

1. 创建一个目录，然后从 GitHub存储库中克隆示例源代码。

   ```
   git clone https://github.com/aws/amazon-kinesis-video-streams-parser-library
   ```

1. 打开您正使用的 Java IDE (例如，[Eclipse](https://www.eclipse.org/) 或 [IntelliJ IDEA](https://www.jetbrains.com/idea/))，并导入您下载的 Apache Maven 项目：
   + **在 Eclipse 中：**选择 **File**、**Import**、**Maven**、**Existing Maven Projects**。导航到 `kinesis-video-streams-parser-lib` 目录。
   + **在 IntelliJ Idea 中：**选择 **Import**。导航到下载的程序包的根目录中的 `pom.xml` 文件。
**注意**  
如果 IntelliJ 找不到您的依赖项，则可能需要执行以下操作：  
**干净生成**：选择 **File (文件)**、**Settings (设置)**、**Build, Execution, Deployment (生成、执行、部署)**、**Compiler (编译器)**。确认已选中 “**重建时清除输出目录**”，然后选择 “**构建**，**生成项目**”。
**重新导入项目：**打开该项目的上下文菜单（右键单击），选择 **Maven**、**重新导入**。

    有关更多信息，请参阅相关的 IDE 文档。

1. 从您的 Java IDE 中，打开 `src/test/java/com.amazonaws.kinesisvideo.parser/examples/KinesisVideoRendererExampleTest`。

1. 从该文件中删除 `@Ignore` 指令。

1. 使用您的 Kinesis 视频流的名称更新该`.stream`参数。

1. 运行 `KinesisVideoRendererExample` 测试。

## 工作方式
<a name="examples-renderer-howitworks"></a>

**Topics**
+ [发送 MKV 数据](#examples-renderer-howitworks-send)
+ [将 MKV 片段解析成帧](#examples-renderer-howitworks-parse)
+ [解码并显示画面](#examples-renderer-howitworks-display)

### 发送 MKV 数据
<a name="examples-renderer-howitworks-send"></a>

该示例从`rendering_example_video.mkv`文件中发送示例 MKV 数据，`PutMedia`用于将视频数据发送到名为**render-example-stream**的流。

该应用程序创建一个 `PutMediaWorker`：

```
PutMediaWorker putMediaWorker = PutMediaWorker.create(getRegion(),
    getCredentialsProvider(),
    getStreamName(),
    inputStream,
    streamOps.amazonKinesisVideo);
executorService.submit(putMediaWorker);
```

有关 `PutMediaWorker` 类的信息，请参阅[使用解析器库进行直播](parser-library.md)文档中的 [打电话 PutMedia](parser-library-write.md#parser-library-write-example-putmedia)。

### 将 MKV 片段解析成帧
<a name="examples-renderer-howitworks-parse"></a>

然后，该示例使用 `GetMediaWorker` 从流中检索和解析 MKV 片段：

```
GetMediaWorker getMediaWorker = GetMediaWorker.create(getRegion(),
    getCredentialsProvider(),
    getStreamName(),
    new StartSelector().withStartSelectorType(StartSelectorType.EARLIEST),
    streamOps.amazonKinesisVideo,
    getMediaProcessingArgumentsLocal.getFrameVisitor());
executorService.submit(getMediaWorker);
```

有关 `GetMediaWorker` 类的更多信息，请参阅[使用解析器库进行直播](parser-library.md)文档中的 [打电话 GetMedia](parser-library-write.md#parser-library-write-example-getmedia)。

### 解码并显示画面
<a name="examples-renderer-howitworks-display"></a>

然后，该示例使用[JFrame](https://docs.oracle.com/javase/7/docs/api/javax/swing/JFrame.html)解码并显示框架。

以下代码示例来自于 `KinesisVideoFrameViewer` 类，该类扩展了 `JFrame`：

```
 public void setImage(BufferedImage bufferedImage) {
    image = bufferedImage;
    repaint();
}
```

该图像显示为 [java.awt.image 的实例。 BufferedImage](https://docs.oracle.com/javase/7/docs/api/java/awt/image/BufferedImage.html)。有关说明如何使用 `BufferedImage` 的示例，请参阅[读取/加载图像](https://docs.oracle.com/javase/tutorial/2d/images/loadimage.html)。