aws-sdk-kinesisvideoarchivedmedia 1.16.0 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7f983615a3b757d4ca06b404645a2ec26bdf62ba
-  data.tar.gz: 177654450b09e52ca906c5e49a036878e602a0cc
+  metadata.gz: 95afbb9a6043fd08e4dd249c3b62bab68eb27617
+  data.tar.gz: b2999bac55287f27f509a1deac6df995cc980a73
 SHA512:
-  metadata.gz: bdd217b290c50f315a36ab0d169aeab8b244d75c6b3be5ccab99f78db8783ace9a44cd33396ec767915056ca176aaa65701e6570f9112e68782f1c416ae942ce
-  data.tar.gz: 95226f28f0a504c521a48c75870a46b2eb1df898ed6a4c53133305d6592609d3dfdf9b8f6150ade079283bd85085d6ef321857569cd382fba908c5e2ef48b382
+  metadata.gz: c43d018a7da30b83dc66d7930bcee345b4e17ff9c36c1a4e5219d35407165bb6ab99b79021ce4d488d93058d5327b235e2426bc8c4cc70787a84ec0d1a941b03
+  data.tar.gz: 6c214bafde60fb22e28bb775eeb9824b16fd890030f50fe9ef24cadaaecd885ea4a14df24063c605a95c015129b259fb3b2513b2ac6c19b9488787992ddc93cc

data/lib/aws-sdk-kinesisvideoarchivedmedia.rb

@@ -42,6 +42,6 @@ require_relative 'aws-sdk-kinesisvideoarchivedmedia/customizations'
 # @service
 module Aws::KinesisVideoArchivedMedia
 
-  GEM_VERSION = '1.16.0'
+  GEM_VERSION = '1.17.0'
 
 end

data/lib/aws-sdk-kinesisvideoarchivedmedia/client.rb

@@ -254,36 +254,385 @@ module Aws::KinesisVideoArchivedMedia
 
     # @!group API Operations
 
+    # Retrieves an MPEG Dynamic Adaptive Streaming over HTTP (DASH) URL for
+    # the stream. You can then open the URL in a media player to view the
+    # stream contents.
+    #
+    # Both the `StreamName` and the `StreamARN` parameters are optional, but
+    # you must specify either the `StreamName` or the `StreamARN` when
+    # invoking this API operation.
+    #
+    # An Amazon Kinesis video stream has the following requirements for
+    # providing data through MPEG-DASH:
+    #
+    # * The media must contain h.264 or h.265 encoded video and, optionally,
+    #   AAC or G.711 encoded audio. Specifically, the codec id of track 1
+    #   should be `V_MPEG/ISO/AVC` (for h.264) or V\_MPEGH/ISO/HEVC (for
+    #   H.265). Optionally, the codec id of track 2 should be `A_AAC` (for
+    #   AAC) or A\_MS/ACM (for G.711).
+    #
+    # * Data retention must be greater than 0.
+    #
+    # * The video track of each fragment must contain codec private data in
+    #   the Advanced Video Coding (AVC) for H.264 format and HEVC for H.265
+    #   format. For more information, see [MPEG-4 specification ISO/IEC
+    #   14496-15][1]. For information about adapting stream data to a given
+    #   format, see [NAL Adaptation Flags][2].
+    #
+    # * The audio track (if present) of each fragment must contain codec
+    #   private data in the AAC format ([AAC specification ISO/IEC
+    #   13818-7][3]) or the [MS Wave format][4].
+    #
+    # The following procedure shows how to use MPEG-DASH with Kinesis Video
+    # Streams:
+    #
+    # 1.  Get an endpoint using [GetDataEndpoint][5], specifying
+    #     `GET_DASH_STREAMING_SESSION_URL` for the `APIName` parameter.
+    #
+    # 2.  Retrieve the MPEG-DASH URL using `GetDASHStreamingSessionURL`.
+    #     Kinesis Video Streams creates an MPEG-DASH streaming session to be
+    #     used for accessing content in a stream using the MPEG-DASH
+    #     protocol. `GetDASHStreamingSessionURL` returns an authenticated
+    #     URL (that includes an encrypted session token) for the session's
+    #     MPEG-DASH *manifest* (the root resource needed for streaming with
+    #     MPEG-DASH).
+    #
+    #     <note markdown="1"> Don't share or store this token where an unauthorized entity
+    #     could access it. The token provides access to the content of the
+    #     stream. Safeguard the token with the same measures that you would
+    #     use with your AWS credentials.
+    #
+    #      </note>
+    #
+    #     The media that is made available through the manifest consists
+    #     only of the requested stream, time range, and format. No other
+    #     media data (such as frames outside the requested window or
+    #     alternate bitrates) is made available.
+    #
+    # 3.  Provide the URL (containing the encrypted session token) for the
+    #     MPEG-DASH manifest to a media player that supports the MPEG-DASH
+    #     protocol. Kinesis Video Streams makes the initialization fragment,
+    #     and media fragments available through the manifest URL. The
+    #     initialization fragment contains the codec private data for the
+    #     stream, and other data needed to set up the video or audio decoder
+    #     and renderer. The media fragments contain encoded video frames or
+    #     encoded audio samples.
+    #
+    # 4.  The media player receives the authenticated URL and requests
+    #     stream metadata and media data normally. When the media player
+    #     requests data, it calls the following actions:
+    #
+    #     * **GetDASHManifest:** Retrieves an MPEG DASH manifest, which
+    #       contains the metadata for the media that you want to playback.
+    #
+    #     * **GetMP4InitFragment:** Retrieves the MP4 initialization
+    #       fragment. The media player typically loads the initialization
+    #       fragment before loading any media fragments. This fragment
+    #       contains the "`fytp`" and "`moov`" MP4 atoms, and the child
+    #       atoms that are needed to initialize the media player decoder.
+    #
+    #       The initialization fragment does not correspond to a fragment in
+    #       a Kinesis video stream. It contains only the codec private data
+    #       for the stream and respective track, which the media player
+    #       needs to decode the media frames.
+    #
+    #     * **GetMP4MediaFragment:** Retrieves MP4 media fragments. These
+    #       fragments contain the "`moof`" and "`mdat`" MP4 atoms and
+    #       their child atoms, containing the encoded fragment's media
+    #       frames and their timestamps.
+    #
+    #       <note markdown="1"> After the first media fragment is made available in a streaming
+    #       session, any fragments that don't contain the same codec
+    #       private data cause an error to be returned when those different
+    #       media fragments are loaded. Therefore, the codec private data
+    #       should not change between fragments in a session. This also
+    #       means that the session fails if the fragments in a stream change
+    #       from having only video to having both audio and video.
+    #
+    #        </note>
+    #
+    #       Data retrieved with this action is billable. See [Pricing][6]
+    #       for details.
+    #
+    # <note markdown="1"> The following restrictions apply to MPEG-DASH sessions:
+    #
+    #  * A streaming session URL should not be shared between players. The
+    #   service might throttle a session if multiple media players are
+    #   sharing it. For connection limits, see [Kinesis Video Streams
+    #   Limits][7].
+    #
+    # * A Kinesis video stream can have a maximum of ten active MPEG-DASH
+    #   streaming sessions. If a new session is created when the maximum
+    #   number of sessions is already active, the oldest (earliest created)
+    #   session is closed. The number of active `GetMedia` connections on a
+    #   Kinesis video stream does not count against this limit, and the
+    #   number of active MPEG-DASH sessions does not count against the
+    #   active `GetMedia` connection limit.
+    #
+    #   <note markdown="1"> The maximum limits for active HLS and MPEG-DASH streaming sessions
+    #   are independent of each other.
+    #
+    #    </note>
+    #
+    #  </note>
+    #
+    # You can monitor the amount of data that the media player consumes by
+    # monitoring the `GetMP4MediaFragment.OutgoingBytes` Amazon CloudWatch
+    # metric. For information about using CloudWatch to monitor Kinesis
+    # Video Streams, see [Monitoring Kinesis Video Streams][8]. For pricing
+    # information, see [Amazon Kinesis Video Streams Pricing][6] and [AWS
+    # Pricing][9]. Charges for both HLS sessions and outgoing AWS data
+    # apply.
+    #
+    # For more information about HLS, see [HTTP Live Streaming][10] on the
+    # [Apple Developer site][11].
+    #
+    # If an error is thrown after invoking a Kinesis Video Streams archived
+    # media API, in addition to the HTTP status code and the response body,
+    # it includes the following pieces of information:
+    #
+    #  * `x-amz-ErrorType` HTTP header – contains a more specific error type
+    #   in addition to what the HTTP status code provides.
+    #
+    # * `x-amz-RequestId` HTTP header – if you want to report an issue to
+    #   AWS, the support team can better diagnose the problem if given the
+    #   Request Id.
+    #
+    #  Both the HTTP status code and the ErrorType header can be utilized to
+    # make programmatic decisions about whether errors are retry-able and
+    # under what conditions, as well as provide information on what actions
+    # the client programmer might need to take in order to successfully try
+    # again.
+    #
+    #  For more information, see the **Errors** section at the bottom of
+    # this
+    # topic, as well as [Common Errors][12].
+    #
+    #
+    #
+    # [1]: https://www.iso.org/standard/55980.html
+    # [2]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/producer-reference-nal.html
+    # [3]: https://www.iso.org/standard/43345.html
+    # [4]: http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
+    # [5]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_GetDataEndpoint.html
+    # [6]: https://aws.amazon.com/kinesis/video-streams/pricing/
+    # [7]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/limits.html
+    # [8]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/monitoring.html
+    # [9]: https://aws.amazon.com/pricing/
+    # [10]: https://developer.apple.com/streaming/
+    # [11]: https://developer.apple.com
+    # [12]: https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/CommonErrors.html
+    #
+    # @option params [String] :stream_name
+    #   The name of the stream for which to retrieve the MPEG-DASH manifest
+    #   URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #
+    # @option params [String] :stream_arn
+    #   The Amazon Resource Name (ARN) of the stream for which to retrieve the
+    #   MPEG-DASH manifest URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #
+    # @option params [String] :playback_mode
+    #   Whether to retrieve live, live replay, or archived, on-demand data.
+    #
+    #   Features of the three types of sessions include the following:
+    #
+    #   * <b> <code>LIVE</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest is continually updated with the latest fragments
+    #     as they become available. We recommend that the media player
+    #     retrieve a new manifest on a one-second interval. When this type of
+    #     session is played in a media player, the user interface typically
+    #     displays a "live" notification, with no scrubber control for
+    #     choosing the position in the playback window to display.
+    #
+    #     <note markdown="1"> In `LIVE` mode, the newest available fragments are included in an
+    #     MPEG-DASH manifest, even if there is a gap between fragments (that
+    #     is, if a fragment is missing). A gap like this might cause a media
+    #     player to halt or cause a jump in playback. In this mode, fragments
+    #     are not added to the MPEG-DASH manifest if they are older than the
+    #     newest fragment in the playlist. If the missing fragment becomes
+    #     available after a subsequent fragment is added to the manifest, the
+    #     older fragment is not added, and the gap is not filled.
+    #
+    #      </note>
+    #
+    #   * <b> <code>LIVE_REPLAY</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest is updated similarly to how it is updated for
+    #     `LIVE` mode except that it starts by including fragments from a
+    #     given start time. Instead of fragments being added as they are
+    #     ingested, fragments are added as the duration of the next fragment
+    #     elapses. For example, if the fragments in the session are two
+    #     seconds long, then a new fragment is added to the manifest every two
+    #     seconds. This mode is useful to be able to start playback from when
+    #     an event is detected and continue live streaming media that has not
+    #     yet been ingested as of the time of the session creation. This mode
+    #     is also useful to stream previously archived media without being
+    #     limited by the 1,000 fragment limit in the `ON_DEMAND` mode.
+    #
+    #   * <b> <code>ON_DEMAND</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest contains all the fragments for the session, up to
+    #     the number that is specified in `MaxMediaPlaylistFragmentResults`.
+    #     The manifest must be retrieved only once for each session. When this
+    #     type of session is played in a media player, the user interface
+    #     typically displays a scrubber control for choosing the position in
+    #     the playback window to display.
+    #
+    #   In all playback modes, if `FragmentSelectorType` is
+    #   `PRODUCER_TIMESTAMP`, and if there are multiple fragments with the
+    #   same start timestamp, the fragment that has the larger fragment number
+    #   (that is, the newer fragment) is included in the MPEG-DASH manifest.
+    #   The other fragments are not included. Fragments that have different
+    #   timestamps but have overlapping durations are still included in the
+    #   MPEG-DASH manifest. This can lead to unexpected behavior in the media
+    #   player.
+    #
+    #   The default is `LIVE`.
+    #
+    # @option params [String] :display_fragment_timestamp
+    #   Per the MPEG-DASH specification, the wall-clock time of fragments in
+    #   the manifest file can be derived using attributes in the manifest
+    #   itself. However, typically, MPEG-DASH compatible media players do not
+    #   properly handle gaps in the media timeline. Kinesis Video Streams
+    #   adjusts the media timeline in the manifest file to enable playback of
+    #   media with discontinuities. Therefore, the wall-clock time derived
+    #   from the manifest file may be inaccurate. If DisplayFragmentTimestamp
+    #   is set to `ALWAYS`, the accurate fragment timestamp is added to each S
+    #   element in the manifest file with the attribute name “kvs:ts”. A
+    #   custom MPEG-DASH media player is necessary to leverage this custom
+    #   attribute.
+    #
+    #   The default value is `NEVER`. When DASHFragmentSelector is
+    #   `SERVER_TIMESTAMP`, the timestamps will be the server start
+    #   timestamps. Similarly, when DASHFragmentSelector is
+    #   `PRODUCER_TIMESTAMP`, the timestamps will be the producer start
+    #   timestamps.
+    #
+    # @option params [String] :display_fragment_number
+    #   Fragments are identified in the manifest file based on their sequence
+    #   number in the session. If DisplayFragmentNumber is set to `ALWAYS`,
+    #   the Kinesis Video Streams fragment number is added to each S element
+    #   in the manifest file with the attribute name “kvs:fn”. These fragment
+    #   numbers can be used for logging or for use with other APIs (e.g.
+    #   `GetMedia` and `GetMediaForFragmentList`). A custom MPEG-DASH media
+    #   player is necessary to leverage these this custom attribute.
+    #
+    #   The default value is `NEVER`.
+    #
+    # @option params [Types::DASHFragmentSelector] :dash_fragment_selector
+    #   The time range of the requested fragment, and the source of the
+    #   timestamps.
+    #
+    #   This parameter is required if `PlaybackMode` is `ON_DEMAND` or
+    #   `LIVE_REPLAY`. This parameter is optional if PlaybackMode is` LIVE. If
+    #   PlaybackMode is LIVE, the FragmentSelectorType can be set, but the
+    #   TimestampRange should not be set. If PlaybackMode is ON_DEMAND or
+    #   LIVE_REPLAY, both FragmentSelectorType and TimestampRange must be
+    #   set.</p>
+    #   `
+    #
+    # @option params [Integer] :expires
+    #   The time in seconds until the requested session expires. This value
+    #   can be between 300 (5 minutes) and 43200 (12 hours).
+    #
+    #   When a session expires, no new calls to `GetDashManifest`,
+    #   `GetMP4InitFragment`, or `GetMP4MediaFragment` can be made for that
+    #   session.
+    #
+    #   The default is 300 (5 minutes).
+    #
+    # @option params [Integer] :max_manifest_fragment_results
+    #   The maximum number of fragments that are returned in the MPEG-DASH
+    #   manifest.
+    #
+    #   When the `PlaybackMode` is `LIVE`, the most recent fragments are
+    #   returned up to this value. When the `PlaybackMode` is `ON_DEMAND`, the
+    #   oldest fragments are returned, up to this maximum number.
+    #
+    #   When there are a higher number of fragments available in a live
+    #   MPEG-DASH manifest, video players often buffer content before starting
+    #   playback. Increasing the buffer size increases the playback latency,
+    #   but it decreases the likelihood that rebuffering will occur during
+    #   playback. We recommend that a live MPEG-DASH manifest have a minimum
+    #   of 3 fragments and a maximum of 10 fragments.
+    #
+    #   The default is 5 fragments if `PlaybackMode` is `LIVE` or
+    #   `LIVE_REPLAY`, and 1,000 if `PlaybackMode` is `ON_DEMAND`.
+    #
+    #   The maximum value of 1,000 fragments corresponds to more than 16
+    #   minutes of video on streams with 1-second fragments, and more than 2
+    #   1/2 hours of video on streams with 10-second fragments.
+    #
+    # @return [Types::GetDASHStreamingSessionURLOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::GetDASHStreamingSessionURLOutput#dash_streaming_session_url #dash_streaming_session_url} => String
+    #
+    # @example Request syntax with placeholder values
+    #
+    #   resp = client.get_dash_streaming_session_url({
+    #     stream_name: "StreamName",
+    #     stream_arn: "ResourceARN",
+    #     playback_mode: "LIVE", # accepts LIVE, LIVE_REPLAY, ON_DEMAND
+    #     display_fragment_timestamp: "ALWAYS", # accepts ALWAYS, NEVER
+    #     display_fragment_number: "ALWAYS", # accepts ALWAYS, NEVER
+    #     dash_fragment_selector: {
+    #       fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #       timestamp_range: {
+    #         start_timestamp: Time.now,
+    #         end_timestamp: Time.now,
+    #       },
+    #     },
+    #     expires: 1,
+    #     max_manifest_fragment_results: 1,
+    #   })
+    #
+    # @example Response structure
+    #
+    #   resp.dash_streaming_session_url #=> String
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetDASHStreamingSessionURL AWS API Documentation
+    #
+    # @overload get_dash_streaming_session_url(params = {})
+    # @param [Hash] params ({})
+    def get_dash_streaming_session_url(params = {}, options = {})
+      req = build_request(:get_dash_streaming_session_url, params)
+      req.send_request(options)
+    end
+
     # Retrieves an HTTP Live Streaming (HLS) URL for the stream. You can
     # then open the URL in a browser or media player to view the stream
     # contents.
     #
-    # You must specify either the `StreamName` or the `StreamARN`.
+    # Both the `StreamName` and the `StreamARN` parameters are optional, but
+    # you must specify either the `StreamName` or the `StreamARN` when
+    # invoking this API operation.
     #
     # An Amazon Kinesis video stream has the following requirements for
     # providing data through HLS:
     #
-    # * The media must contain h.264 encoded video and, optionally, AAC
-    #   encoded audio. Specifically, the codec id of track 1 should be
-    #   `V_MPEG/ISO/AVC`. Optionally, the codec id of track 2 should be
-    #   `A_AAC`.
+    # * The media must contain h.264 or h.265 encoded video and, optionally,
+    #   AAC encoded audio. Specifically, the codec id of track 1 should be
+    #   `V_MPEG/ISO/AVC` (for h.264) or `V_MPEG/ISO/HEVC` (for h.265).
+    #   Optionally, the codec id of track 2 should be `A_AAC`.
     #
     # * Data retention must be greater than 0.
     #
     # * The video track of each fragment must contain codec private data in
-    #   the Advanced Video Coding (AVC) for H.264 format ([MPEG-4
-    #   specification ISO/IEC 14496-15][1]). For information about adapting
-    #   stream data to a given format, see [NAL Adaptation Flags][2].
+    #   the Advanced Video Coding (AVC) for H.264 format or HEVC for H.265
+    #   format ([MPEG-4 specification ISO/IEC 14496-15][1]). For information
+    #   about adapting stream data to a given format, see [NAL Adaptation
+    #   Flags][2].
     #
     # * The audio track (if present) of each fragment must contain codec
     #   private data in the AAC format ([AAC specification ISO/IEC
     #   13818-7][3]).
     #
     # Kinesis Video Streams HLS sessions contain fragments in the fragmented
-    # MPEG-4 form (also called fMP4 or CMAF), rather than the MPEG-2 form
-    # (also called TS chunks, which the HLS specification also supports).
-    # For more information about HLS fragment types, see the [HLS
-    # specification][4].
+    # MPEG-4 form (also called fMP4 or CMAF) or the MPEG-2 form (also called
+    # TS chunks, which the HLS specification also supports). For more
+    # information about HLS fragment types, see the [HLS specification][4].
     #
     # The following procedure shows how to use HLS with Kinesis Video
     # Streams:
@@ -390,7 +739,7 @@ module Aws::KinesisVideoArchivedMedia
     #   sharing it. For connection limits, see [Kinesis Video Streams
     #   Limits][7].
     #
-    # * A Kinesis video stream can have a maximum of five active HLS
+    # * A Kinesis video stream can have a maximum of ten active HLS
     #   streaming sessions. If a new session is created when the maximum
     #   number of sessions is already active, the oldest (earliest created)
     #   session is closed. The number of active `GetMedia` connections on a
@@ -398,6 +747,11 @@ module Aws::KinesisVideoArchivedMedia
     #   number of active HLS sessions does not count against the active
     #   `GetMedia` connection limit.
     #
+    #   <note markdown="1"> The maximum limits for active HLS and MPEG-DASH streaming sessions
+    #   are independent of each other.
+    #
+    #    </note>
+    #
     #  </note>
     #
     # You can monitor the amount of data that the media player consumes by
@@ -411,6 +765,27 @@ module Aws::KinesisVideoArchivedMedia
     # For more information about HLS, see [HTTP Live Streaming][10] on the
     # [Apple Developer site][11].
     #
+    # If an error is thrown after invoking a Kinesis Video Streams archived
+    # media API, in addition to the HTTP status code and the response body,
+    # it includes the following pieces of information:
+    #
+    #  * `x-amz-ErrorType` HTTP header – contains a more specific error type
+    #   in addition to what the HTTP status code provides.
+    #
+    # * `x-amz-RequestId` HTTP header – if you want to report an issue to
+    #   AWS, the support team can better diagnose the problem if given the
+    #   Request Id.
+    #
+    #  Both the HTTP status code and the ErrorType header can be utilized to
+    # make programmatic decisions about whether errors are retry-able and
+    # under what conditions, as well as provide information on what actions
+    # the client programmer might need to take in order to successfully try
+    # again.
+    #
+    #  For more information, see the **Errors** section at the bottom of
+    # this
+    # topic, as well as [Common Errors][12].
+    #
     #
     #
     # [1]: https://www.iso.org/standard/55980.html
@@ -424,6 +799,7 @@ module Aws::KinesisVideoArchivedMedia
     # [9]: https://aws.amazon.com/pricing/
     # [10]: https://developer.apple.com/streaming/
     # [11]: https://developer.apple.com
+    # [12]: https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/CommonErrors.html
     #
     # @option params [String] :stream_name
     #   The name of the stream for which to retrieve the HLS master playlist
@@ -438,9 +814,9 @@ module Aws::KinesisVideoArchivedMedia
     #   You must specify either the `StreamName` or the `StreamARN`.
     #
     # @option params [String] :playback_mode
-    #   Whether to retrieve live or archived, on-demand data.
+    #   Whether to retrieve live, live replay, or archived, on-demand data.
     #
-    #   Features of the two types of session include the following:
+    #   Features of the three types of sessions include the following:
     #
     #   * <b> <code>LIVE</code> </b>\: For sessions of this type, the HLS
     #     media playlist is continually updated with the latest fragments as
@@ -461,6 +837,20 @@ module Aws::KinesisVideoArchivedMedia
     #
     #      </note>
     #
+    #   * <b> <code>LIVE_REPLAY</code> </b>\: For sessions of this type, the
+    #     HLS media playlist is updated similarly to how it is updated for
+    #     `LIVE` mode except that it starts by including fragments from a
+    #     given start time. Instead of fragments being added as they are
+    #     ingested, fragments are added as the duration of the next fragment
+    #     elapses. For example, if the fragments in the session are two
+    #     seconds long, then a new fragment is added to the media playlist
+    #     every two seconds. This mode is useful to be able to start playback
+    #     from when an event is detected and continue live streaming media
+    #     that has not yet been ingested as of the time of the session
+    #     creation. This mode is also useful to stream previously archived
+    #     media without being limited by the 1,000 fragment limit in the
+    #     `ON_DEMAND` mode.
+    #
     #   * <b> <code>ON_DEMAND</code> </b>\: For sessions of this type, the HLS
     #     media playlist contains all the fragments for the session, up to the
     #     number that is specified in `MaxMediaPlaylistFragmentResults`. The
@@ -469,7 +859,7 @@ module Aws::KinesisVideoArchivedMedia
     #     typically displays a scrubber control for choosing the position in
     #     the playback window to display.
     #
-    #   In both playback modes, if `FragmentSelectorType` is
+    #   In all playback modes, if `FragmentSelectorType` is
     #   `PRODUCER_TIMESTAMP`, and if there are multiple fragments with the
     #   same start timestamp, the fragment that has the larger fragment number
     #   (that is, the newer fragment) is included in the HLS media playlist.
@@ -484,11 +874,13 @@ module Aws::KinesisVideoArchivedMedia
     #   The time range of the requested fragment, and the source of the
     #   timestamps.
     #
-    #   This parameter is required if `PlaybackMode` is `ON_DEMAND`. This
-    #   parameter is optional if `PlaybackMode` is `LIVE`. If `PlaybackMode`
-    #   is `LIVE`, the `FragmentSelectorType` can be set, but the
-    #   `TimestampRange` should not be set. If `PlaybackMode` is `ON_DEMAND`,
-    #   both `FragmentSelectorType` and `TimestampRange` must be set.
+    #   This parameter is required if `PlaybackMode` is `ON_DEMAND` or
+    #   `LIVE_REPLAY`. This parameter is optional if PlaybackMode is` LIVE. If
+    #   PlaybackMode is LIVE, the FragmentSelectorType can be set, but the
+    #   TimestampRange should not be set. If PlaybackMode is ON_DEMAND or
+    #   LIVE_REPLAY, both FragmentSelectorType and TimestampRange must be
+    #   set.</p>
+    #   `
     #
     # @option params [String] :container_format
     #   Specifies which format should be used for packaging the media.
@@ -543,8 +935,8 @@ module Aws::KinesisVideoArchivedMedia
     #   can be between 300 (5 minutes) and 43200 (12 hours).
     #
     #   When a session expires, no new calls to `GetHLSMasterPlaylist`,
-    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, or `GetMP4MediaFragment`
-    #   can be made for that session.
+    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, `GetMP4MediaFragment`, or
+    #   `GetTSFragment` can be made for that session.
     #
     #   The default is 300 (5 minutes).
     #
@@ -563,8 +955,8 @@ module Aws::KinesisVideoArchivedMedia
     #   playback. We recommend that a live HLS media playlist have a minimum
     #   of 3 fragments and a maximum of 10 fragments.
     #
-    #   The default is 5 fragments if `PlaybackMode` is `LIVE`, and 1,000 if
-    #   `PlaybackMode` is `ON_DEMAND`.
+    #   The default is 5 fragments if `PlaybackMode` is `LIVE` or
+    #   `LIVE_REPLAY`, and 1,000 if `PlaybackMode` is `ON_DEMAND`.
     #
     #   The maximum value of 1,000 fragments corresponds to more than 16
     #   minutes of video on streams with 1-second fragments, and more than 2
@@ -579,7 +971,7 @@ module Aws::KinesisVideoArchivedMedia
     #   resp = client.get_hls_streaming_session_url({
     #     stream_name: "StreamName",
     #     stream_arn: "ResourceARN",
-    #     playback_mode: "LIVE", # accepts LIVE, ON_DEMAND
+    #     playback_mode: "LIVE", # accepts LIVE, LIVE_REPLAY, ON_DEMAND
     #     hls_fragment_selector: {
     #       fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
     #       timestamp_range: {
@@ -626,9 +1018,31 @@ module Aws::KinesisVideoArchivedMedia
     #   megabytes per second (or 200 megabits per second) during a
     #   `GetMediaForFragmentList` session.
     #
+    # If an error is thrown after invoking a Kinesis Video Streams archived
+    # media API, in addition to the HTTP status code and the response body,
+    # it includes the following pieces of information:
+    #
+    #  * `x-amz-ErrorType` HTTP header – contains a more specific error type
+    #   in addition to what the HTTP status code provides.
+    #
+    # * `x-amz-RequestId` HTTP header – if you want to report an issue to
+    #   AWS, the support team can better diagnose the problem if given the
+    #   Request Id.
+    #
+    #  Both the HTTP status code and the ErrorType header can be utilized to
+    # make programmatic decisions about whether errors are retry-able and
+    # under what conditions, as well as provide information on what actions
+    # the client programmer might need to take in order to successfully try
+    # again.
+    #
+    #  For more information, see the **Errors** section at the bottom of
+    # this
+    # topic, as well as [Common Errors][2].
+    #
     #
     #
     # [1]: https://docs.aws.amazon.com/cli/latest/reference/
+    # [2]: https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/CommonErrors.html
     #
     # @option params [required, String] :stream_name
     #   The name of the stream from which to retrieve fragment media.
@@ -678,9 +1092,31 @@ module Aws::KinesisVideoArchivedMedia
     #
     #  </note>
     #
+    # If an error is thrown after invoking a Kinesis Video Streams archived
+    # media API, in addition to the HTTP status code and the response body,
+    # it includes the following pieces of information:
+    #
+    #  * `x-amz-ErrorType` HTTP header – contains a more specific error type
+    #   in addition to what the HTTP status code provides.
+    #
+    # * `x-amz-RequestId` HTTP header – if you want to report an issue to
+    #   AWS, the support team can better diagnose the problem if given the
+    #   Request Id.
+    #
+    #  Both the HTTP status code and the ErrorType header can be utilized to
+    # make programmatic decisions about whether errors are retry-able and
+    # under what conditions, as well as provide information on what actions
+    # the client programmer might need to take in order to successfully try
+    # again.
+    #
+    #  For more information, see the **Errors** section at the bottom of
+    # this
+    # topic, as well as [Common Errors][2].
+    #
     #
     #
     # [1]: https://docs.aws.amazon.com/cli/latest/reference/
+    # [2]: https://docs.aws.amazon.com/kinesisvideostreams/latest/dg/CommonErrors.html
     #
     # @option params [required, String] :stream_name
     #   The name of the stream from which to retrieve a fragment list.
@@ -751,7 +1187,7 @@ module Aws::KinesisVideoArchivedMedia
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-kinesisvideoarchivedmedia'
-      context[:gem_version] = '1.16.0'
+      context[:gem_version] = '1.17.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

data/lib/aws-sdk-kinesisvideoarchivedmedia/client_api.rb

@@ -14,8 +14,13 @@ module Aws::KinesisVideoArchivedMedia
     ClientLimitExceededException = Shapes::StructureShape.new(name: 'ClientLimitExceededException')
     ContainerFormat = Shapes::StringShape.new(name: 'ContainerFormat')
     ContentType = Shapes::StringShape.new(name: 'ContentType')
-    DiscontinuityMode = Shapes::StringShape.new(name: 'DiscontinuityMode')
-    DisplayFragmentTimestamp = Shapes::StringShape.new(name: 'DisplayFragmentTimestamp')
+    DASHDisplayFragmentNumber = Shapes::StringShape.new(name: 'DASHDisplayFragmentNumber')
+    DASHDisplayFragmentTimestamp = Shapes::StringShape.new(name: 'DASHDisplayFragmentTimestamp')
+    DASHFragmentSelector = Shapes::StructureShape.new(name: 'DASHFragmentSelector')
+    DASHFragmentSelectorType = Shapes::StringShape.new(name: 'DASHFragmentSelectorType')
+    DASHPlaybackMode = Shapes::StringShape.new(name: 'DASHPlaybackMode')
+    DASHStreamingSessionURL = Shapes::StringShape.new(name: 'DASHStreamingSessionURL')
+    DASHTimestampRange = Shapes::StructureShape.new(name: 'DASHTimestampRange')
     ErrorMessage = Shapes::StringShape.new(name: 'ErrorMessage')
     Expires = Shapes::IntegerShape.new(name: 'Expires')
     Fragment = Shapes::StructureShape.new(name: 'Fragment')
@@ -24,12 +29,17 @@ module Aws::KinesisVideoArchivedMedia
     FragmentNumberString = Shapes::StringShape.new(name: 'FragmentNumberString')
     FragmentSelector = Shapes::StructureShape.new(name: 'FragmentSelector')
     FragmentSelectorType = Shapes::StringShape.new(name: 'FragmentSelectorType')
+    GetDASHStreamingSessionURLInput = Shapes::StructureShape.new(name: 'GetDASHStreamingSessionURLInput')
+    GetDASHStreamingSessionURLOutput = Shapes::StructureShape.new(name: 'GetDASHStreamingSessionURLOutput')
     GetHLSStreamingSessionURLInput = Shapes::StructureShape.new(name: 'GetHLSStreamingSessionURLInput')
     GetHLSStreamingSessionURLOutput = Shapes::StructureShape.new(name: 'GetHLSStreamingSessionURLOutput')
     GetMediaForFragmentListInput = Shapes::StructureShape.new(name: 'GetMediaForFragmentListInput')
     GetMediaForFragmentListOutput = Shapes::StructureShape.new(name: 'GetMediaForFragmentListOutput')
+    HLSDiscontinuityMode = Shapes::StringShape.new(name: 'HLSDiscontinuityMode')
+    HLSDisplayFragmentTimestamp = Shapes::StringShape.new(name: 'HLSDisplayFragmentTimestamp')
     HLSFragmentSelector = Shapes::StructureShape.new(name: 'HLSFragmentSelector')
     HLSFragmentSelectorType = Shapes::StringShape.new(name: 'HLSFragmentSelectorType')
+    HLSPlaybackMode = Shapes::StringShape.new(name: 'HLSPlaybackMode')
     HLSStreamingSessionURL = Shapes::StringShape.new(name: 'HLSStreamingSessionURL')
     HLSTimestampRange = Shapes::StructureShape.new(name: 'HLSTimestampRange')
     InvalidArgumentException = Shapes::StructureShape.new(name: 'InvalidArgumentException')
@@ -42,7 +52,6 @@ module Aws::KinesisVideoArchivedMedia
     NotAuthorizedException = Shapes::StructureShape.new(name: 'NotAuthorizedException')
     PageLimit = Shapes::IntegerShape.new(name: 'PageLimit')
     Payload = Shapes::BlobShape.new(name: 'Payload', streaming: true)
-    PlaybackMode = Shapes::StringShape.new(name: 'PlaybackMode')
     ResourceARN = Shapes::StringShape.new(name: 'ResourceARN')
     ResourceNotFoundException = Shapes::StructureShape.new(name: 'ResourceNotFoundException')
     StreamName = Shapes::StringShape.new(name: 'StreamName')
@@ -54,6 +63,14 @@ module Aws::KinesisVideoArchivedMedia
     ClientLimitExceededException.add_member(:message, Shapes::ShapeRef.new(shape: ErrorMessage, location_name: "Message"))
     ClientLimitExceededException.struct_class = Types::ClientLimitExceededException
 
+    DASHFragmentSelector.add_member(:fragment_selector_type, Shapes::ShapeRef.new(shape: DASHFragmentSelectorType, location_name: "FragmentSelectorType"))
+    DASHFragmentSelector.add_member(:timestamp_range, Shapes::ShapeRef.new(shape: DASHTimestampRange, location_name: "TimestampRange"))
+    DASHFragmentSelector.struct_class = Types::DASHFragmentSelector
+
+    DASHTimestampRange.add_member(:start_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StartTimestamp"))
+    DASHTimestampRange.add_member(:end_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "EndTimestamp"))
+    DASHTimestampRange.struct_class = Types::DASHTimestampRange
+
     Fragment.add_member(:fragment_number, Shapes::ShapeRef.new(shape: String, location_name: "FragmentNumber"))
     Fragment.add_member(:fragment_size_in_bytes, Shapes::ShapeRef.new(shape: Long, location_name: "FragmentSizeInBytes"))
     Fragment.add_member(:producer_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "ProducerTimestamp"))
@@ -69,13 +86,26 @@ module Aws::KinesisVideoArchivedMedia
     FragmentSelector.add_member(:timestamp_range, Shapes::ShapeRef.new(shape: TimestampRange, required: true, location_name: "TimestampRange"))
     FragmentSelector.struct_class = Types::FragmentSelector
 
+    GetDASHStreamingSessionURLInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
+    GetDASHStreamingSessionURLInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: ResourceARN, location_name: "StreamARN"))
+    GetDASHStreamingSessionURLInput.add_member(:playback_mode, Shapes::ShapeRef.new(shape: DASHPlaybackMode, location_name: "PlaybackMode"))
+    GetDASHStreamingSessionURLInput.add_member(:display_fragment_timestamp, Shapes::ShapeRef.new(shape: DASHDisplayFragmentTimestamp, location_name: "DisplayFragmentTimestamp"))
+    GetDASHStreamingSessionURLInput.add_member(:display_fragment_number, Shapes::ShapeRef.new(shape: DASHDisplayFragmentNumber, location_name: "DisplayFragmentNumber"))
+    GetDASHStreamingSessionURLInput.add_member(:dash_fragment_selector, Shapes::ShapeRef.new(shape: DASHFragmentSelector, location_name: "DASHFragmentSelector"))
+    GetDASHStreamingSessionURLInput.add_member(:expires, Shapes::ShapeRef.new(shape: Expires, location_name: "Expires"))
+    GetDASHStreamingSessionURLInput.add_member(:max_manifest_fragment_results, Shapes::ShapeRef.new(shape: PageLimit, location_name: "MaxManifestFragmentResults"))
+    GetDASHStreamingSessionURLInput.struct_class = Types::GetDASHStreamingSessionURLInput
+
+    GetDASHStreamingSessionURLOutput.add_member(:dash_streaming_session_url, Shapes::ShapeRef.new(shape: DASHStreamingSessionURL, location_name: "DASHStreamingSessionURL"))
+    GetDASHStreamingSessionURLOutput.struct_class = Types::GetDASHStreamingSessionURLOutput
+
     GetHLSStreamingSessionURLInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, location_name: "StreamName"))
     GetHLSStreamingSessionURLInput.add_member(:stream_arn, Shapes::ShapeRef.new(shape: ResourceARN, location_name: "StreamARN"))
-    GetHLSStreamingSessionURLInput.add_member(:playback_mode, Shapes::ShapeRef.new(shape: PlaybackMode, location_name: "PlaybackMode"))
+    GetHLSStreamingSessionURLInput.add_member(:playback_mode, Shapes::ShapeRef.new(shape: HLSPlaybackMode, location_name: "PlaybackMode"))
     GetHLSStreamingSessionURLInput.add_member(:hls_fragment_selector, Shapes::ShapeRef.new(shape: HLSFragmentSelector, location_name: "HLSFragmentSelector"))
     GetHLSStreamingSessionURLInput.add_member(:container_format, Shapes::ShapeRef.new(shape: ContainerFormat, location_name: "ContainerFormat"))
-    GetHLSStreamingSessionURLInput.add_member(:discontinuity_mode, Shapes::ShapeRef.new(shape: DiscontinuityMode, location_name: "DiscontinuityMode"))
-    GetHLSStreamingSessionURLInput.add_member(:display_fragment_timestamp, Shapes::ShapeRef.new(shape: DisplayFragmentTimestamp, location_name: "DisplayFragmentTimestamp"))
+    GetHLSStreamingSessionURLInput.add_member(:discontinuity_mode, Shapes::ShapeRef.new(shape: HLSDiscontinuityMode, location_name: "DiscontinuityMode"))
+    GetHLSStreamingSessionURLInput.add_member(:display_fragment_timestamp, Shapes::ShapeRef.new(shape: HLSDisplayFragmentTimestamp, location_name: "DisplayFragmentTimestamp"))
     GetHLSStreamingSessionURLInput.add_member(:expires, Shapes::ShapeRef.new(shape: Expires, location_name: "Expires"))
     GetHLSStreamingSessionURLInput.add_member(:max_media_playlist_fragment_results, Shapes::ShapeRef.new(shape: PageLimit, location_name: "MaxMediaPlaylistFragmentResults"))
     GetHLSStreamingSessionURLInput.struct_class = Types::GetHLSStreamingSessionURLInput
@@ -153,6 +183,22 @@ module Aws::KinesisVideoArchivedMedia
         "uid" => "kinesis-video-archived-media-2017-09-30",
       }
 
+      api.add_operation(:get_dash_streaming_session_url, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "GetDASHStreamingSessionURL"
+        o.http_method = "POST"
+        o.http_request_uri = "/getDASHStreamingSessionURL"
+        o.input = Shapes::ShapeRef.new(shape: GetDASHStreamingSessionURLInput)
+        o.output = Shapes::ShapeRef.new(shape: GetDASHStreamingSessionURLOutput)
+        o.errors << Shapes::ShapeRef.new(shape: ResourceNotFoundException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
+        o.errors << Shapes::ShapeRef.new(shape: ClientLimitExceededException)
+        o.errors << Shapes::ShapeRef.new(shape: NotAuthorizedException)
+        o.errors << Shapes::ShapeRef.new(shape: UnsupportedStreamMediaTypeException)
+        o.errors << Shapes::ShapeRef.new(shape: NoDataRetentionException)
+        o.errors << Shapes::ShapeRef.new(shape: MissingCodecPrivateDataException)
+        o.errors << Shapes::ShapeRef.new(shape: InvalidCodecPrivateDataException)
+      end)
+
       api.add_operation(:get_hls_streaming_session_url, Seahorse::Model::Operation.new.tap do |o|
         o.name = "GetHLSStreamingSessionURL"
         o.http_method = "POST"
@@ -191,6 +237,12 @@ module Aws::KinesisVideoArchivedMedia
         o.errors << Shapes::ShapeRef.new(shape: InvalidArgumentException)
         o.errors << Shapes::ShapeRef.new(shape: ClientLimitExceededException)
         o.errors << Shapes::ShapeRef.new(shape: NotAuthorizedException)
+        o[:pager] = Aws::Pager.new(
+          limit_key: "max_results",
+          tokens: {
+            "next_token" => "next_token"
+          }
+        )
       end)
     end
 

data/lib/aws-sdk-kinesisvideoarchivedmedia/types.rb

@@ -21,10 +21,133 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
+    # Contains the range of timestamps for the requested media, and the
+    # source of the timestamps.
+    #
+    # @note When making an API call, you may pass DASHFragmentSelector
+    #   data as a hash:
+    #
+    #       {
+    #         fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #         timestamp_range: {
+    #           start_timestamp: Time.now,
+    #           end_timestamp: Time.now,
+    #         },
+    #       }
+    #
+    # @!attribute [rw] fragment_selector_type
+    #   The source of the timestamps for the requested media.
+    #
+    #   When `FragmentSelectorType` is set to `PRODUCER_TIMESTAMP` and
+    #   GetDASHStreamingSessionURLInput$PlaybackMode is `ON_DEMAND` or
+    #   `LIVE_REPLAY`, the first fragment ingested with a producer timestamp
+    #   within the specified FragmentSelector$TimestampRange is included in
+    #   the media playlist. In addition, the fragments with producer
+    #   timestamps within the `TimestampRange` ingested immediately
+    #   following the first fragment (up to the
+    #   GetDASHStreamingSessionURLInput$MaxManifestFragmentResults value)
+    #   are included.
+    #
+    #   Fragments that have duplicate producer timestamps are deduplicated.
+    #   This means that if producers are producing a stream of fragments
+    #   with producer timestamps that are approximately equal to the true
+    #   clock time, the MPEG-DASH manifest will contain all of the fragments
+    #   within the requested timestamp range. If some fragments are ingested
+    #   within the same time range and very different points in time, only
+    #   the oldest ingested collection of fragments are returned.
+    #
+    #   When `FragmentSelectorType` is set to `PRODUCER_TIMESTAMP` and
+    #   GetDASHStreamingSessionURLInput$PlaybackMode is `LIVE`, the producer
+    #   timestamps are used in the MP4 fragments and for deduplication. But
+    #   the most recently ingested fragments based on server timestamps are
+    #   included in the MPEG-DASH manifest. This means that even if
+    #   fragments ingested in the past have producer timestamps with values
+    #   now, they are not included in the HLS media playlist.
+    #
+    #   The default is `SERVER_TIMESTAMP`.
+    #   @return [String]
+    #
+    # @!attribute [rw] timestamp_range
+    #   The start and end of the timestamp range for the requested media.
+    #
+    #   This value should not be present if `PlaybackType` is `LIVE`.
+    #   @return [Types::DASHTimestampRange]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/DASHFragmentSelector AWS API Documentation
+    #
+    class DASHFragmentSelector < Struct.new(
+      :fragment_selector_type,
+      :timestamp_range)
+      include Aws::Structure
+    end
+
+    # The start and end of the timestamp range for the requested media.
+    #
+    # This value should not be present if `PlaybackType` is `LIVE`.
+    #
+    # <note markdown="1"> The values in the `DASHimestampRange` are inclusive. Fragments that
+    # begin before the start time but continue past it, or fragments that
+    # begin before the end time but continue past it, are included in the
+    # session.
+    #
+    #  </note>
+    #
+    # @note When making an API call, you may pass DASHTimestampRange
+    #   data as a hash:
+    #
+    #       {
+    #         start_timestamp: Time.now,
+    #         end_timestamp: Time.now,
+    #       }
+    #
+    # @!attribute [rw] start_timestamp
+    #   The start of the timestamp range for the requested media.
+    #
+    #   If the `DASHTimestampRange` value is specified, the `StartTimestamp`
+    #   value is required.
+    #
+    #   <note markdown="1"> This value is inclusive. Fragments that start before the
+    #   `StartTimestamp` and continue past it are included in the session.
+    #   If `FragmentSelectorType` is `SERVER_TIMESTAMP`, the
+    #   `StartTimestamp` must be later than the stream head.
+    #
+    #    </note>
+    #   @return [Time]
+    #
+    # @!attribute [rw] end_timestamp
+    #   The end of the timestamp range for the requested media. This value
+    #   must be within 3 hours of the specified `StartTimestamp`, and it
+    #   must be later than the `StartTimestamp` value.
+    #
+    #   If `FragmentSelectorType` for the request is `SERVER_TIMESTAMP`,
+    #   this value must be in the past.
+    #
+    #   The `EndTimestamp` value is required for `ON_DEMAND` mode, but
+    #   optional for `LIVE_REPLAY` mode. If the `EndTimestamp` is not set
+    #   for `LIVE_REPLAY` mode then the session will continue to include
+    #   newly ingested fragments until the session expires.
+    #
+    #   <note markdown="1"> This value is inclusive. The `EndTimestamp` is compared to the
+    #   (starting) timestamp of the fragment. Fragments that start before
+    #   the `EndTimestamp` value and continue past it are included in the
+    #   session.
+    #
+    #    </note>
+    #   @return [Time]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/DASHTimestampRange AWS API Documentation
+    #
+    class DASHTimestampRange < Struct.new(
+      :start_timestamp,
+      :end_timestamp)
+      include Aws::Structure
+    end
+
     # Represents a segment of video or other time-delimited data.
     #
     # @!attribute [rw] fragment_number
-    #   The index value of the fragment.
+    #   The unique identifier of the fragment. This value monotonically
+    #   increases based on the ingestion order.
     #   @return [String]
     #
     # @!attribute [rw] fragment_size_in_bytes
@@ -103,13 +226,214 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
+    # @note When making an API call, you may pass GetDASHStreamingSessionURLInput
+    #   data as a hash:
+    #
+    #       {
+    #         stream_name: "StreamName",
+    #         stream_arn: "ResourceARN",
+    #         playback_mode: "LIVE", # accepts LIVE, LIVE_REPLAY, ON_DEMAND
+    #         display_fragment_timestamp: "ALWAYS", # accepts ALWAYS, NEVER
+    #         display_fragment_number: "ALWAYS", # accepts ALWAYS, NEVER
+    #         dash_fragment_selector: {
+    #           fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #           timestamp_range: {
+    #             start_timestamp: Time.now,
+    #             end_timestamp: Time.now,
+    #           },
+    #         },
+    #         expires: 1,
+    #         max_manifest_fragment_results: 1,
+    #       }
+    #
+    # @!attribute [rw] stream_name
+    #   The name of the stream for which to retrieve the MPEG-DASH manifest
+    #   URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #   @return [String]
+    #
+    # @!attribute [rw] stream_arn
+    #   The Amazon Resource Name (ARN) of the stream for which to retrieve
+    #   the MPEG-DASH manifest URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #   @return [String]
+    #
+    # @!attribute [rw] playback_mode
+    #   Whether to retrieve live, live replay, or archived, on-demand data.
+    #
+    #   Features of the three types of sessions include the following:
+    #
+    #   * <b> <code>LIVE</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest is continually updated with the latest
+    #     fragments as they become available. We recommend that the media
+    #     player retrieve a new manifest on a one-second interval. When this
+    #     type of session is played in a media player, the user interface
+    #     typically displays a "live" notification, with no scrubber
+    #     control for choosing the position in the playback window to
+    #     display.
+    #
+    #     <note markdown="1"> In `LIVE` mode, the newest available fragments are included in an
+    #     MPEG-DASH manifest, even if there is a gap between fragments (that
+    #     is, if a fragment is missing). A gap like this might cause a media
+    #     player to halt or cause a jump in playback. In this mode,
+    #     fragments are not added to the MPEG-DASH manifest if they are
+    #     older than the newest fragment in the playlist. If the missing
+    #     fragment becomes available after a subsequent fragment is added to
+    #     the manifest, the older fragment is not added, and the gap is not
+    #     filled.
+    #
+    #      </note>
+    #
+    #   * <b> <code>LIVE_REPLAY</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest is updated similarly to how it is updated for
+    #     `LIVE` mode except that it starts by including fragments from a
+    #     given start time. Instead of fragments being added as they are
+    #     ingested, fragments are added as the duration of the next fragment
+    #     elapses. For example, if the fragments in the session are two
+    #     seconds long, then a new fragment is added to the manifest every
+    #     two seconds. This mode is useful to be able to start playback from
+    #     when an event is detected and continue live streaming media that
+    #     has not yet been ingested as of the time of the session creation.
+    #     This mode is also useful to stream previously archived media
+    #     without being limited by the 1,000 fragment limit in the
+    #     `ON_DEMAND` mode.
+    #
+    #   * <b> <code>ON_DEMAND</code> </b>\: For sessions of this type, the
+    #     MPEG-DASH manifest contains all the fragments for the session, up
+    #     to the number that is specified in
+    #     `MaxMediaPlaylistFragmentResults`. The manifest must be retrieved
+    #     only once for each session. When this type of session is played in
+    #     a media player, the user interface typically displays a scrubber
+    #     control for choosing the position in the playback window to
+    #     display.
+    #
+    #   In all playback modes, if `FragmentSelectorType` is
+    #   `PRODUCER_TIMESTAMP`, and if there are multiple fragments with the
+    #   same start timestamp, the fragment that has the larger fragment
+    #   number (that is, the newer fragment) is included in the MPEG-DASH
+    #   manifest. The other fragments are not included. Fragments that have
+    #   different timestamps but have overlapping durations are still
+    #   included in the MPEG-DASH manifest. This can lead to unexpected
+    #   behavior in the media player.
+    #
+    #   The default is `LIVE`.
+    #   @return [String]
+    #
+    # @!attribute [rw] display_fragment_timestamp
+    #   Per the MPEG-DASH specification, the wall-clock time of fragments in
+    #   the manifest file can be derived using attributes in the manifest
+    #   itself. However, typically, MPEG-DASH compatible media players do
+    #   not properly handle gaps in the media timeline. Kinesis Video
+    #   Streams adjusts the media timeline in the manifest file to enable
+    #   playback of media with discontinuities. Therefore, the wall-clock
+    #   time derived from the manifest file may be inaccurate. If
+    #   DisplayFragmentTimestamp is set to `ALWAYS`, the accurate fragment
+    #   timestamp is added to each S element in the manifest file with the
+    #   attribute name “kvs:ts”. A custom MPEG-DASH media player is
+    #   necessary to leverage this custom attribute.
+    #
+    #   The default value is `NEVER`. When DASHFragmentSelector is
+    #   `SERVER_TIMESTAMP`, the timestamps will be the server start
+    #   timestamps. Similarly, when DASHFragmentSelector is
+    #   `PRODUCER_TIMESTAMP`, the timestamps will be the producer start
+    #   timestamps.
+    #   @return [String]
+    #
+    # @!attribute [rw] display_fragment_number
+    #   Fragments are identified in the manifest file based on their
+    #   sequence number in the session. If DisplayFragmentNumber is set to
+    #   `ALWAYS`, the Kinesis Video Streams fragment number is added to each
+    #   S element in the manifest file with the attribute name “kvs:fn”.
+    #   These fragment numbers can be used for logging or for use with other
+    #   APIs (e.g. `GetMedia` and `GetMediaForFragmentList`). A custom
+    #   MPEG-DASH media player is necessary to leverage these this custom
+    #   attribute.
+    #
+    #   The default value is `NEVER`.
+    #   @return [String]
+    #
+    # @!attribute [rw] dash_fragment_selector
+    #   The time range of the requested fragment, and the source of the
+    #   timestamps.
+    #
+    #   This parameter is required if `PlaybackMode` is `ON_DEMAND` or
+    #   `LIVE_REPLAY`. This parameter is optional if PlaybackMode is` LIVE.
+    #   If PlaybackMode is LIVE, the FragmentSelectorType can be set, but
+    #   the TimestampRange should not be set. If PlaybackMode is ON_DEMAND
+    #   or LIVE_REPLAY, both FragmentSelectorType and TimestampRange must be
+    #   set.</p>
+    #   `
+    #   @return [Types::DASHFragmentSelector]
+    #
+    # @!attribute [rw] expires
+    #   The time in seconds until the requested session expires. This value
+    #   can be between 300 (5 minutes) and 43200 (12 hours).
+    #
+    #   When a session expires, no new calls to `GetDashManifest`,
+    #   `GetMP4InitFragment`, or `GetMP4MediaFragment` can be made for that
+    #   session.
+    #
+    #   The default is 300 (5 minutes).
+    #   @return [Integer]
+    #
+    # @!attribute [rw] max_manifest_fragment_results
+    #   The maximum number of fragments that are returned in the MPEG-DASH
+    #   manifest.
+    #
+    #   When the `PlaybackMode` is `LIVE`, the most recent fragments are
+    #   returned up to this value. When the `PlaybackMode` is `ON_DEMAND`,
+    #   the oldest fragments are returned, up to this maximum number.
+    #
+    #   When there are a higher number of fragments available in a live
+    #   MPEG-DASH manifest, video players often buffer content before
+    #   starting playback. Increasing the buffer size increases the playback
+    #   latency, but it decreases the likelihood that rebuffering will occur
+    #   during playback. We recommend that a live MPEG-DASH manifest have a
+    #   minimum of 3 fragments and a maximum of 10 fragments.
+    #
+    #   The default is 5 fragments if `PlaybackMode` is `LIVE` or
+    #   `LIVE_REPLAY`, and 1,000 if `PlaybackMode` is `ON_DEMAND`.
+    #
+    #   The maximum value of 1,000 fragments corresponds to more than 16
+    #   minutes of video on streams with 1-second fragments, and more than 2
+    #   1/2 hours of video on streams with 10-second fragments.
+    #   @return [Integer]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetDASHStreamingSessionURLInput AWS API Documentation
+    #
+    class GetDASHStreamingSessionURLInput < Struct.new(
+      :stream_name,
+      :stream_arn,
+      :playback_mode,
+      :display_fragment_timestamp,
+      :display_fragment_number,
+      :dash_fragment_selector,
+      :expires,
+      :max_manifest_fragment_results)
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] dash_streaming_session_url
+    #   The URL (containing the session token) that a media player can use
+    #   to retrieve the MPEG-DASH manifest.
+    #   @return [String]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetDASHStreamingSessionURLOutput AWS API Documentation
+    #
+    class GetDASHStreamingSessionURLOutput < Struct.new(
+      :dash_streaming_session_url)
+      include Aws::Structure
+    end
+
     # @note When making an API call, you may pass GetHLSStreamingSessionURLInput
     #   data as a hash:
     #
     #       {
     #         stream_name: "StreamName",
     #         stream_arn: "ResourceARN",
-    #         playback_mode: "LIVE", # accepts LIVE, ON_DEMAND
+    #         playback_mode: "LIVE", # accepts LIVE, LIVE_REPLAY, ON_DEMAND
     #         hls_fragment_selector: {
     #           fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
     #           timestamp_range: {
@@ -139,9 +463,9 @@ module Aws::KinesisVideoArchivedMedia
     #   @return [String]
     #
     # @!attribute [rw] playback_mode
-    #   Whether to retrieve live or archived, on-demand data.
+    #   Whether to retrieve live, live replay, or archived, on-demand data.
     #
-    #   Features of the two types of session include the following:
+    #   Features of the three types of sessions include the following:
     #
     #   * <b> <code>LIVE</code> </b>\: For sessions of this type, the HLS
     #     media playlist is continually updated with the latest fragments as
@@ -163,6 +487,20 @@ module Aws::KinesisVideoArchivedMedia
     #
     #      </note>
     #
+    #   * <b> <code>LIVE_REPLAY</code> </b>\: For sessions of this type, the
+    #     HLS media playlist is updated similarly to how it is updated for
+    #     `LIVE` mode except that it starts by including fragments from a
+    #     given start time. Instead of fragments being added as they are
+    #     ingested, fragments are added as the duration of the next fragment
+    #     elapses. For example, if the fragments in the session are two
+    #     seconds long, then a new fragment is added to the media playlist
+    #     every two seconds. This mode is useful to be able to start
+    #     playback from when an event is detected and continue live
+    #     streaming media that has not yet been ingested as of the time of
+    #     the session creation. This mode is also useful to stream
+    #     previously archived media without being limited by the 1,000
+    #     fragment limit in the `ON_DEMAND` mode.
+    #
     #   * <b> <code>ON_DEMAND</code> </b>\: For sessions of this type, the
     #     HLS media playlist contains all the fragments for the session, up
     #     to the number that is specified in
@@ -172,7 +510,7 @@ module Aws::KinesisVideoArchivedMedia
     #     control for choosing the position in the playback window to
     #     display.
     #
-    #   In both playback modes, if `FragmentSelectorType` is
+    #   In all playback modes, if `FragmentSelectorType` is
     #   `PRODUCER_TIMESTAMP`, and if there are multiple fragments with the
     #   same start timestamp, the fragment that has the larger fragment
     #   number (that is, the newer fragment) is included in the HLS media
@@ -188,12 +526,13 @@ module Aws::KinesisVideoArchivedMedia
     #   The time range of the requested fragment, and the source of the
     #   timestamps.
     #
-    #   This parameter is required if `PlaybackMode` is `ON_DEMAND`. This
-    #   parameter is optional if `PlaybackMode` is `LIVE`. If `PlaybackMode`
-    #   is `LIVE`, the `FragmentSelectorType` can be set, but the
-    #   `TimestampRange` should not be set. If `PlaybackMode` is
-    #   `ON_DEMAND`, both `FragmentSelectorType` and `TimestampRange` must
-    #   be set.
+    #   This parameter is required if `PlaybackMode` is `ON_DEMAND` or
+    #   `LIVE_REPLAY`. This parameter is optional if PlaybackMode is` LIVE.
+    #   If PlaybackMode is LIVE, the FragmentSelectorType can be set, but
+    #   the TimestampRange should not be set. If PlaybackMode is ON_DEMAND
+    #   or LIVE_REPLAY, both FragmentSelectorType and TimestampRange must be
+    #   set.</p>
+    #   `
     #   @return [Types::HLSFragmentSelector]
     #
     # @!attribute [rw] container_format
@@ -253,8 +592,8 @@ module Aws::KinesisVideoArchivedMedia
     #   can be between 300 (5 minutes) and 43200 (12 hours).
     #
     #   When a session expires, no new calls to `GetHLSMasterPlaylist`,
-    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, or
-    #   `GetMP4MediaFragment` can be made for that session.
+    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, `GetMP4MediaFragment`,
+    #   or `GetTSFragment` can be made for that session.
     #
     #   The default is 300 (5 minutes).
     #   @return [Integer]
@@ -274,8 +613,8 @@ module Aws::KinesisVideoArchivedMedia
     #   playback. We recommend that a live HLS media playlist have a minimum
     #   of 3 fragments and a maximum of 10 fragments.
     #
-    #   The default is 5 fragments if `PlaybackMode` is `LIVE`, and 1,000 if
-    #   `PlaybackMode` is `ON_DEMAND`.
+    #   The default is 5 fragments if `PlaybackMode` is `LIVE` or
+    #   `LIVE_REPLAY`, and 1,000 if `PlaybackMode` is `ON_DEMAND`.
     #
     #   The maximum value of 1,000 fragments corresponds to more than 16
     #   minutes of video on streams with 1-second fragments, and more than 2
@@ -396,12 +735,12 @@ module Aws::KinesisVideoArchivedMedia
     #   The source of the timestamps for the requested media.
     #
     #   When `FragmentSelectorType` is set to `PRODUCER_TIMESTAMP` and
-    #   GetHLSStreamingSessionURLInput$PlaybackMode is `ON_DEMAND`, the
-    #   first fragment ingested with a producer timestamp within the
-    #   specified FragmentSelector$TimestampRange is included in the media
-    #   playlist. In addition, the fragments with producer timestamps within
-    #   the `TimestampRange` ingested immediately following the first
-    #   fragment (up to the
+    #   GetHLSStreamingSessionURLInput$PlaybackMode is `ON_DEMAND` or
+    #   `LIVE_REPLAY`, the first fragment ingested with a producer timestamp
+    #   within the specified FragmentSelector$TimestampRange is included in
+    #   the media playlist. In addition, the fragments with producer
+    #   timestamps within the `TimestampRange` ingested immediately
+    #   following the first fragment (up to the
     #   GetHLSStreamingSessionURLInput$MaxMediaPlaylistFragmentResults
     #   value) are included.
     #
@@ -479,8 +818,10 @@ module Aws::KinesisVideoArchivedMedia
     #   If `FragmentSelectorType` for the request is `SERVER_TIMESTAMP`,
     #   this value must be in the past.
     #
-    #   If the `HLSTimestampRange` value is specified, the `EndTimestamp`
-    #   value is required.
+    #   The `EndTimestamp` value is required for `ON_DEMAND` mode, but
+    #   optional for `LIVE_REPLAY` mode. If the `EndTimestamp` is not set
+    #   for `LIVE_REPLAY` mode then the session will continue to include
+    #   newly ingested fragments until the session expires.
     #
     #   <note markdown="1"> This value is inclusive. The `EndTimestamp` is compared to the
     #   (starting) timestamp of the fragment. Fragments that start before
@@ -604,8 +945,8 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
-    # A `PlaybackMode` of `ON_DEMAND` was requested for a stream that does
-    # not retain data (that is, has a `DataRetentionInHours` of 0).
+    # A streaming session was requested for a stream that does not retain
+    # data (that is, has a `DataRetentionInHours` of 0).
     #
     # @!attribute [rw] message
     #   @return [String]
@@ -633,11 +974,12 @@ module Aws::KinesisVideoArchivedMedia
     # `GetMedia` throws this error when Kinesis Video Streams can't find
     # the stream that you specified.
     #
-    # `GetHLSStreamingSessionURL` throws this error if a session with a
-    # `PlaybackMode` of `ON_DEMAND` is requested for a stream that has no
-    # fragments within the requested time range, or if a session with a
-    # `PlaybackMode` of `LIVE` is requested for a stream that has no
-    # fragments within the last 30 seconds.
+    # `GetHLSStreamingSessionURL` and `GetDASHStreamingSessionURL` throw
+    # this error if a session with a `PlaybackMode` of `ON_DEMAND` or
+    # `LIVE_REPLAY`is requested for a stream that has no fragments within
+    # the requested time range, or if a session with a `PlaybackMode` of
+    # `LIVE` is requested for a stream that has no fragments within the last
+    # 30 seconds.
     #
     # @!attribute [rw] message
     #   @return [String]
@@ -677,11 +1019,11 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
-    # The type of the media (for example, h.264 video or ACC audio) could
-    # not be determined from the codec IDs of the tracks in the first
-    # fragment for a playback session. The codec ID for track 1 should be
-    # `V_MPEG/ISO/AVC` and, optionally, the codec ID for track 2 should be
-    # `A_AAC`.
+    # The type of the media (for example, h.264 or h.265 video or ACC or
+    # G.711 audio) could not be determined from the codec IDs of the tracks
+    # in the first fragment for a playback session. The codec ID for track 1
+    # should be `V_MPEG/ISO/AVC` and, optionally, the codec ID for track 2
+    # should be `A_AAC`.
     #
     # @!attribute [rw] message
     #   @return [String]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-kinesisvideoarchivedmedia
 version: !ruby/object:Gem::Version
-  version: 1.16.0
+  version: 1.17.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-01 00:00:00.000000000 Z
+date: 2019-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core