aws-sdk-kinesisvideoarchivedmedia 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9265abd211e9d699e897a757676fb061db3f0662
-  data.tar.gz: ceb3b79ac1d7414310f03e990060ebdf22887d36
+  metadata.gz: 94844d8f11bcddb68a3dfa0b9284275ee0793cc7
+  data.tar.gz: 53f46ecb5f44556da15c49a17a2a14011dfcbff0
 SHA512:
-  metadata.gz: c4fe3937f182d949a6a7fc3cef1c10d4b4544eb18070c29d0a057c3bca194b9e4eb9effb98dac8915d4538d9397097bc0e621123d257650362e00f4145b5c947
-  data.tar.gz: 57cd750819ec9ac4c0e2b98da1164a4333cfaab730071d4c4d46a1fcd4eaf7364e6546b5bbe8d8da8ffcbd15cb6fbe9e0f04ab21cfbf8ff50d3fa7b1e2ed9cb2
+  metadata.gz: eb78af1d98d4018ab6bcd53a298467323763d444f30c6ee1e30ecc34ead1b72a9cdf15dc73bdddd21e983267fc4f029111cea6a0274c7e07b35c385790f21a9d
+  data.tar.gz: c31a95a2fdc968864f687c4b28343f210506770f50d62bbcc7a330725e53f1be2b9d443f53f03544daa1aea4417fefa6a1f93da5157b7bb9ef4a5e236e6d8394

data/lib/aws-sdk-kinesisvideoarchivedmedia.rb

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

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

@@ -156,14 +156,308 @@ module Aws::KinesisVideoArchivedMedia
 
     # @!group API Operations
 
-    # Gets media for a list of fragments (specified by fragment number) from
-    # the archived data in a Kinesis video stream.
-    #
-    # <note markdown="1"> This operation is only available for the AWS SDK for Java. It is not
-    # supported in AWS SDKs for other languages.
+    # 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`.
+    #
+    # An Amazon Kinesis video stream has the following requirements for
+    # providing data through HLS:
+    #
+    # * The media type must be `video/h264`.
+    #
+    # * Data retention must be greater than 0.
+    #
+    # * The fragments must contain codec private data in the AVC (Advanced
+    #   Video Coding) 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].
+    #
+    # 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][3].
+    #
+    # The following procedure shows how to use HLS with Kinesis Video
+    # Streams:
+    #
+    # 1.  Get an endpoint using [GetDataEndpoint][4], specifying
+    #     `GET_HLS_STREAMING_SESSION_URL` for the `APIName` parameter.
+    #
+    # 2.  Retrieve the HLS URL using `GetHLSStreamingSessionURL`. Kinesis
+    #     Video Streams creates an HLS streaming session to be used for
+    #     accessing content in a stream using the HLS protocol.
+    #     `GetHLSStreamingSessionURL` returns an authenticated URL (that
+    #     includes an encrypted session token) for the session's HLS
+    #     *master playlist* (the root resource needed for streaming with
+    #     HLS).
+    #
+    #     <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 playlist consists
+    #     only of the requested stream, time range, and format. No other
+    #     media data (such as frames outside the requested window or
+    #     alternate bit rates) is made available.
+    #
+    # 3.  Provide the URL (containing the encrypted session token) for the
+    #     HLS master playlist to a media player that supports the HLS
+    #     protocol. Kinesis Video Streams makes the HLS media playlist,
+    #     initialization fragment, and media fragments available through the
+    #     master playlist URL. The initialization fragment contains the
+    #     codec private data for the stream, and other data needed to set up
+    #     the video decoder and renderer. The media fragments contain
+    #     H.264-encoded video frames and time stamps.
+    #
+    # 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:
+    #
+    #     * **GetHLSMasterPlaylist:** Retrieves an HLS master playlist,
+    #       which contains a URL for the `GetHLSMediaPlaylist` action, and
+    #       additional metadata for the media player, including estimated
+    #       bit rate and resolution.
+    #
+    #     * **GetHLSMediaPlaylist:** Retrieves an HLS media playlist, which
+    #       contains a URL to access the MP4 initialization fragment with
+    #       the `GetMP4InitFragment` action, and URLs to access the MP4
+    #       media fragments with the `GetMP4MediaFragment` actions. The HLS
+    #       media playlist also contains metadata about the stream that the
+    #       player needs to play it, such as whether the `PlaybackMode` is
+    #       `LIVE` or `ON_DEMAND`. The HLS media playlist is typically
+    #       static for sessions with a `PlaybackType` of `ON_DEMAND`. The
+    #       HLS media playlist is continually updated with new fragments for
+    #       sessions with a `PlaybackType` of `LIVE`.
+    #
+    #     * **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, which the media player needs to decode video
+    #       frames.
+    #
+    #     * **GetMP4MediaFragment:** Retrieves MP4 media fragments. These
+    #       fragments contain the "`moof`" and "`mdat`" MP4 atoms and
+    #       their child atoms, containing the encoded fragment's video
+    #       frames and their time stamps.
+    #
+    #       <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 are excluded in the HLS media playlist. Therefore,
+    #       the codec private data does not change between fragments in a
+    #       session.
+    #
+    #        </note>
+    #
+    #       Data retrieved with this action is billable. See
+    #       [Pricing](aws.amazon.comkinesis/video-streams/pricing/) for
+    #       details.
+    #
+    # <note markdown="1"> The following restrictions apply to HLS 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][5].
+    #
+    # * A Kinesis video stream can have a maximum of five 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
+    #   Kinesis video stream does not count against this limit, and the
+    #   number of active HLS sessions does not count against the active
+    #   `GetMedia` connection limit.
     #
     #  </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][6]. For pricing
+    # information, see [Amazon Kinesis Video Streams Pricing][7] and [AWS
+    # Pricing][8]. Charges for both HLS sessions and outgoing AWS data
+    # apply.
+    #
+    # For more information about HLS, see [HTTP Live Streaming][9] on the
+    # [Apple Developer site][10].
+    #
+    #
+    #
+    # [1]: https://www.iso.org/standard/55980.html
+    # [2]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/latest/dg/producer-reference-nal.html
+    # [3]: https://tools.ietf.org/html/draft-pantos-http-live-streaming-23
+    # [4]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_GetDataEndpoint.html
+    # [5]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/limits.html
+    # [6]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/monitoring.html
+    # [7]: https://aws.amazon.com/kinesis/video-streams/pricing/
+    # [8]: https://aws.amazon.com/pricing/
+    # [9]: https://developer.apple.com/streaming/
+    # [10]: https://developer.apple.com
+    #
+    # @option params [String] :stream_name
+    #   The name of the stream for which to retrieve the HLS master playlist
+    #   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
+    #   HLS master playlist URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #
+    # @option params [String] :playback_mode
+    #   Whether to retrieve live or archived, on-demand data.
+    #
+    #   Features of the two types of session 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
+    #     they become available. We recommend that the media player retrieve a
+    #     new playlist 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
+    #     HLS media playlist, 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 HLS media playlist 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 playlist, the
+    #     older fragment is not added, and the gap is not filled.
+    #
+    #      </note>
+    #
+    #   * <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
+    #     playlist 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 both playback modes, if `FragmentSelectorType` is
+    #   `PRODUCER_TIMESTAMP`, and if there are multiple fragments with the
+    #   same start time stamp, the fragment that has the larger fragment
+    #   number (that is, the newer fragment) is included in the HLS media
+    #   playlist. The other fragments are not included. Fragments that have
+    #   different time stamps but have overlapping durations are still
+    #   included in the HLS media playlist. This can lead to unexpected
+    #   behavior in the media player.
+    #
+    #   The default is `LIVE`.
+    #
+    # @option params [Types::HLSFragmentSelector] :hls_fragment_selector
+    #   The time range of the requested fragment, and the source of the time
+    #   stamps.
+    #
+    #   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.
+    #
+    # @option params [String] :discontinuity_mode
+    #   Specifies when flags marking discontinuities between fragments will be
+    #   added to the media playlists. The default is `ALWAYS` when
+    #   HLSFragmentSelector is `SERVER_TIMESTAMP`, and `NEVER` when it is
+    #   `PRODUCER_TIMESTAMP`.
+    #
+    #   Media players typically build a timeline of media content to play,
+    #   based on the time stamps of each fragment. This means that if there is
+    #   any overlap between fragments (as is typical if HLSFragmentSelector is
+    #   `SERVER_TIMESTAMP`), the media player timeline has small gaps between
+    #   fragments in some places, and overwrites frames in other places. When
+    #   there are discontinuity flags between fragments, the media player is
+    #   expected to reset the timeline, resulting in the fragment being played
+    #   immediately after the previous fragment. We recommend that you always
+    #   have discontinuity flags between fragments if the fragment time stamps
+    #   are not accurate or if fragments might be missing. You should not
+    #   place discontinuity flags between fragments for the player timeline to
+    #   accurately map to the producer time stamps.
+    #
+    # @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 `GetHLSMasterPlaylist`,
+    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, or `GetMP4MediaFragment`
+    #   can be made for that session.
+    #
+    #   The default is 300 (5 minutes).
+    #
+    # @option params [Integer] :max_media_playlist_fragment_results
+    #   The maximum number of fragments that are returned in the HLS media
+    #   playlists.
+    #
+    #   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 HLS
+    #   media playlist, 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 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 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::GetHLSStreamingSessionURLOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
+    #
+    #   * {Types::GetHLSStreamingSessionURLOutput#hls_streaming_session_url #hls_streaming_session_url} => String
+    #
+    # @example Request syntax with placeholder values
+    #
+    #   resp = client.get_hls_streaming_session_url({
+    #     stream_name: "StreamName",
+    #     stream_arn: "ResourceARN",
+    #     playback_mode: "LIVE", # accepts LIVE, ON_DEMAND
+    #     hls_fragment_selector: {
+    #       fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #       timestamp_range: {
+    #         start_timestamp: Time.now,
+    #         end_timestamp: Time.now,
+    #       },
+    #     },
+    #     discontinuity_mode: "ALWAYS", # accepts ALWAYS, NEVER
+    #     expires: 1,
+    #     max_media_playlist_fragment_results: 1,
+    #   })
+    #
+    # @example Response structure
+    #
+    #   resp.hls_streaming_session_url #=> String
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetHLSStreamingSessionURL AWS API Documentation
+    #
+    # @overload get_hls_streaming_session_url(params = {})
+    # @param [Hash] params ({})
+    def get_hls_streaming_session_url(params = {}, options = {})
+      req = build_request(:get_hls_streaming_session_url, params)
+      req.send_request(options)
+    end
+
+    # Gets media for a list of fragments (specified by fragment number) from
+    # the archived data in an Amazon Kinesis video stream.
+    #
     # The following limits apply when using the `GetMediaForFragmentList`
     # API:
     #
@@ -279,7 +573,7 @@ module Aws::KinesisVideoArchivedMedia
         params: params,
         config: config)
       context[:gem_name] = 'aws-sdk-kinesisvideoarchivedmedia'
-      context[:gem_version] = '1.1.0'
+      context[:gem_version] = '1.2.0'
       Seahorse::Client::Request.new(handlers, context)
     end
 

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

@@ -13,27 +13,41 @@ module Aws::KinesisVideoArchivedMedia
 
     ClientLimitExceededException = Shapes::StructureShape.new(name: 'ClientLimitExceededException')
     ContentType = Shapes::StringShape.new(name: 'ContentType')
+    DiscontinuityMode = Shapes::StringShape.new(name: 'DiscontinuityMode')
     ErrorMessage = Shapes::StringShape.new(name: 'ErrorMessage')
+    Expires = Shapes::IntegerShape.new(name: 'Expires')
     Fragment = Shapes::StructureShape.new(name: 'Fragment')
     FragmentList = Shapes::ListShape.new(name: 'FragmentList')
     FragmentNumberList = Shapes::ListShape.new(name: 'FragmentNumberList')
     FragmentNumberString = Shapes::StringShape.new(name: 'FragmentNumberString')
     FragmentSelector = Shapes::StructureShape.new(name: 'FragmentSelector')
     FragmentSelectorType = Shapes::StringShape.new(name: 'FragmentSelectorType')
+    GetHLSStreamingSessionURLInput = Shapes::StructureShape.new(name: 'GetHLSStreamingSessionURLInput')
+    GetHLSStreamingSessionURLOutput = Shapes::StructureShape.new(name: 'GetHLSStreamingSessionURLOutput')
     GetMediaForFragmentListInput = Shapes::StructureShape.new(name: 'GetMediaForFragmentListInput')
     GetMediaForFragmentListOutput = Shapes::StructureShape.new(name: 'GetMediaForFragmentListOutput')
+    HLSFragmentSelector = Shapes::StructureShape.new(name: 'HLSFragmentSelector')
+    HLSFragmentSelectorType = Shapes::StringShape.new(name: 'HLSFragmentSelectorType')
+    HLSStreamingSessionURL = Shapes::StringShape.new(name: 'HLSStreamingSessionURL')
+    HLSTimestampRange = Shapes::StructureShape.new(name: 'HLSTimestampRange')
     InvalidArgumentException = Shapes::StructureShape.new(name: 'InvalidArgumentException')
+    InvalidCodecPrivateDataException = Shapes::StructureShape.new(name: 'InvalidCodecPrivateDataException')
     ListFragmentsInput = Shapes::StructureShape.new(name: 'ListFragmentsInput')
     ListFragmentsOutput = Shapes::StructureShape.new(name: 'ListFragmentsOutput')
     Long = Shapes::IntegerShape.new(name: 'Long')
+    MissingCodecPrivateDataException = Shapes::StructureShape.new(name: 'MissingCodecPrivateDataException')
+    NoDataRetentionException = Shapes::StructureShape.new(name: 'NoDataRetentionException')
     NotAuthorizedException = Shapes::StructureShape.new(name: 'NotAuthorizedException')
     PageLimit = Shapes::IntegerShape.new(name: 'PageLimit')
     Payload = Shapes::BlobShape.new(name: 'Payload')
+    PlaybackMode = Shapes::StringShape.new(name: 'PlaybackMode')
+    ResourceARN = Shapes::StringShape.new(name: 'ResourceARN')
     ResourceNotFoundException = Shapes::StructureShape.new(name: 'ResourceNotFoundException')
     StreamName = Shapes::StringShape.new(name: 'StreamName')
     String = Shapes::StringShape.new(name: 'String')
     Timestamp = Shapes::TimestampShape.new(name: 'Timestamp')
     TimestampRange = Shapes::StructureShape.new(name: 'TimestampRange')
+    UnsupportedStreamMediaTypeException = Shapes::StructureShape.new(name: 'UnsupportedStreamMediaTypeException')
 
     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"))
@@ -50,6 +64,18 @@ module Aws::KinesisVideoArchivedMedia
     FragmentSelector.add_member(:timestamp_range, Shapes::ShapeRef.new(shape: TimestampRange, required: true, location_name: "TimestampRange"))
     FragmentSelector.struct_class = Types::FragmentSelector
 
+    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(:hls_fragment_selector, Shapes::ShapeRef.new(shape: HLSFragmentSelector, location_name: "HLSFragmentSelector"))
+    GetHLSStreamingSessionURLInput.add_member(:discontinuity_mode, Shapes::ShapeRef.new(shape: DiscontinuityMode, location_name: "DiscontinuityMode"))
+    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
+
+    GetHLSStreamingSessionURLOutput.add_member(:hls_streaming_session_url, Shapes::ShapeRef.new(shape: HLSStreamingSessionURL, location_name: "HLSStreamingSessionURL"))
+    GetHLSStreamingSessionURLOutput.struct_class = Types::GetHLSStreamingSessionURLOutput
+
     GetMediaForFragmentListInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, required: true, location_name: "StreamName"))
     GetMediaForFragmentListInput.add_member(:fragments, Shapes::ShapeRef.new(shape: FragmentNumberList, required: true, location_name: "Fragments"))
     GetMediaForFragmentListInput.struct_class = Types::GetMediaForFragmentListInput
@@ -60,6 +86,14 @@ module Aws::KinesisVideoArchivedMedia
     GetMediaForFragmentListOutput[:payload] = :payload
     GetMediaForFragmentListOutput[:payload_member] = GetMediaForFragmentListOutput.member(:payload)
 
+    HLSFragmentSelector.add_member(:fragment_selector_type, Shapes::ShapeRef.new(shape: HLSFragmentSelectorType, location_name: "FragmentSelectorType"))
+    HLSFragmentSelector.add_member(:timestamp_range, Shapes::ShapeRef.new(shape: HLSTimestampRange, location_name: "TimestampRange"))
+    HLSFragmentSelector.struct_class = Types::HLSFragmentSelector
+
+    HLSTimestampRange.add_member(:start_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "StartTimestamp"))
+    HLSTimestampRange.add_member(:end_timestamp, Shapes::ShapeRef.new(shape: Timestamp, location_name: "EndTimestamp"))
+    HLSTimestampRange.struct_class = Types::HLSTimestampRange
+
     ListFragmentsInput.add_member(:stream_name, Shapes::ShapeRef.new(shape: StreamName, required: true, location_name: "StreamName"))
     ListFragmentsInput.add_member(:max_results, Shapes::ShapeRef.new(shape: PageLimit, location_name: "MaxResults"))
     ListFragmentsInput.add_member(:next_token, Shapes::ShapeRef.new(shape: String, location_name: "NextToken"))
@@ -87,6 +121,22 @@ module Aws::KinesisVideoArchivedMedia
         "signatureVersion" => "v4",
       }
 
+      api.add_operation(:get_hls_streaming_session_url, Seahorse::Model::Operation.new.tap do |o|
+        o.name = "GetHLSStreamingSessionURL"
+        o.http_method = "POST"
+        o.http_request_uri = "/getHLSStreamingSessionURL"
+        o.input = Shapes::ShapeRef.new(shape: GetHLSStreamingSessionURLInput)
+        o.output = Shapes::ShapeRef.new(shape: GetHLSStreamingSessionURLOutput)
+        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_media_for_fragment_list, Seahorse::Model::Operation.new.tap do |o|
         o.name = "GetMediaForFragmentList"
         o.http_method = "POST"

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

@@ -73,6 +73,177 @@ module Aws::KinesisVideoArchivedMedia
       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
+    #         hls_fragment_selector: {
+    #           fragment_selector_type: "PRODUCER_TIMESTAMP", # accepts PRODUCER_TIMESTAMP, SERVER_TIMESTAMP
+    #           timestamp_range: {
+    #             start_timestamp: Time.now,
+    #             end_timestamp: Time.now,
+    #           },
+    #         },
+    #         discontinuity_mode: "ALWAYS", # accepts ALWAYS, NEVER
+    #         expires: 1,
+    #         max_media_playlist_fragment_results: 1,
+    #       }
+    #
+    # @!attribute [rw] stream_name
+    #   The name of the stream for which to retrieve the HLS master playlist
+    #   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 HLS master playlist URL.
+    #
+    #   You must specify either the `StreamName` or the `StreamARN`.
+    #   @return [String]
+    #
+    # @!attribute [rw] playback_mode
+    #   Whether to retrieve live or archived, on-demand data.
+    #
+    #   Features of the two types of session 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
+    #     they become available. We recommend that the media player retrieve
+    #     a new playlist 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
+    #     HLS media playlist, 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 HLS media playlist 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 playlist, the older fragment is not added, and the gap is not
+    #     filled.
+    #
+    #      </note>
+    #
+    #   * <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 playlist 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 both playback modes, if `FragmentSelectorType` is
+    #   `PRODUCER_TIMESTAMP`, and if there are multiple fragments with the
+    #   same start time stamp, the fragment that has the larger fragment
+    #   number (that is, the newer fragment) is included in the HLS media
+    #   playlist. The other fragments are not included. Fragments that have
+    #   different time stamps but have overlapping durations are still
+    #   included in the HLS media playlist. This can lead to unexpected
+    #   behavior in the media player.
+    #
+    #   The default is `LIVE`.
+    #   @return [String]
+    #
+    # @!attribute [rw] hls_fragment_selector
+    #   The time range of the requested fragment, and the source of the time
+    #   stamps.
+    #
+    #   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.
+    #   @return [Types::HLSFragmentSelector]
+    #
+    # @!attribute [rw] discontinuity_mode
+    #   Specifies when flags marking discontinuities between fragments will
+    #   be added to the media playlists. The default is `ALWAYS` when
+    #   HLSFragmentSelector is `SERVER_TIMESTAMP`, and `NEVER` when it is
+    #   `PRODUCER_TIMESTAMP`.
+    #
+    #   Media players typically build a timeline of media content to play,
+    #   based on the time stamps of each fragment. This means that if there
+    #   is any overlap between fragments (as is typical if
+    #   HLSFragmentSelector is `SERVER_TIMESTAMP`), the media player
+    #   timeline has small gaps between fragments in some places, and
+    #   overwrites frames in other places. When there are discontinuity
+    #   flags between fragments, the media player is expected to reset the
+    #   timeline, resulting in the fragment being played immediately after
+    #   the previous fragment. We recommend that you always have
+    #   discontinuity flags between fragments if the fragment time stamps
+    #   are not accurate or if fragments might be missing. You should not
+    #   place discontinuity flags between fragments for the player timeline
+    #   to accurately map to the producer time stamps.
+    #   @return [String]
+    #
+    # @!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 `GetHLSMasterPlaylist`,
+    #   `GetHLSMediaPlaylist`, `GetMP4InitFragment`, or
+    #   `GetMP4MediaFragment` can be made for that session.
+    #
+    #   The default is 300 (5 minutes).
+    #   @return [Integer]
+    #
+    # @!attribute [rw] max_media_playlist_fragment_results
+    #   The maximum number of fragments that are returned in the HLS media
+    #   playlists.
+    #
+    #   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 HLS
+    #   media playlist, 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 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 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/GetHLSStreamingSessionURLInput AWS API Documentation
+    #
+    class GetHLSStreamingSessionURLInput < Struct.new(
+      :stream_name,
+      :stream_arn,
+      :playback_mode,
+      :hls_fragment_selector,
+      :discontinuity_mode,
+      :expires,
+      :max_media_playlist_fragment_results)
+      include Aws::Structure
+    end
+
+    # @!attribute [rw] hls_streaming_session_url
+    #   The URL (containing the session token) that a media player can use
+    #   to retrieve the HLS master playlist.
+    #   @return [String]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetHLSStreamingSessionURLOutput AWS API Documentation
+    #
+    class GetHLSStreamingSessionURLOutput < Struct.new(
+      :hls_streaming_session_url)
+      include Aws::Structure
+    end
+
     # @note When making an API call, you may pass GetMediaForFragmentListInput
     #   data as a hash:
     #
@@ -105,11 +276,9 @@ module Aws::KinesisVideoArchivedMedia
     # @!attribute [rw] payload
     #   The payload that Kinesis Video Streams returns is a sequence of
     #   chunks from the specified stream. For information about the chunks,
-    #   see
-    #   [PutMedia](docs.aws.amazon.com/acuity/latest/dg/API_dataplane_PutMedia.html).
-    #   The chunks that Kinesis Video Streams returns in the
-    #   `GetMediaForFragmentList` call also include the following additional
-    #   Matroska (MKV) tags:
+    #   see [PutMedia][1]. The chunks that Kinesis Video Streams returns in
+    #   the `GetMediaForFragmentList` call also include the following
+    #   additional Matroska (MKV) tags:
     #
     #   * AWS\_KINESISVIDEO\_FRAGMENT\_NUMBER - Fragment number returned in
     #     the chunk.
@@ -130,6 +299,10 @@ module Aws::KinesisVideoArchivedMedia
     #
     #   * AWS\_KINESISVIDEO\_EXCEPTION\_MESSAGE - A text description of the
     #     exception
+    #
+    #
+    #
+    #   [1]: http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/API_dataplane_PutMedia.html
     #   @return [IO]
     #
     # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/GetMediaForFragmentListOutput AWS API Documentation
@@ -140,6 +313,126 @@ module Aws::KinesisVideoArchivedMedia
       include Aws::Structure
     end
 
+    # Contains the range of time stamps for the requested media, and the
+    # source of the time stamps.
+    #
+    # @note When making an API call, you may pass HLSFragmentSelector
+    #   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 time stamps for the requested media.
+    #
+    #   When `FragmentSelectorType` is set to `PRODUCER_TIMESTAMP` and
+    #   GetHLSStreamingSessionURLInput$PlaybackMode is `ON_DEMAND`, the
+    #   first fragment ingested with a producer time stamp within the
+    #   specified FragmentSelector$TimestampRange is included in the media
+    #   playlist. In addition, the fragments with producer time stamps
+    #   within the `TimestampRange` ingested immediately following the first
+    #   fragment (up to the
+    #   GetHLSStreamingSessionURLInput$MaxMediaPlaylistFragmentResults
+    #   value) are included.
+    #
+    #   Fragments that have duplicate producer time stamps are deduplicated.
+    #   This means that if producers are producing a stream of fragments
+    #   with producer time stamps that are approximately equal to the true
+    #   clock time, the HLS media playlists will contain all of the
+    #   fragments within the requested time stamp 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
+    #   GetHLSStreamingSessionURLInput$PlaybackMode is `LIVE`, the producer
+    #   time stamps are used in the MP4 fragments and for deduplication. But
+    #   the most recently ingested fragments based on server time stamps are
+    #   included in the HLS media playlist. This means that even if
+    #   fragments ingested in the past have producer time stamps 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 time stamp range for the requested media.
+    #
+    #   This value should not be present if `PlaybackType` is `LIVE`.
+    #   @return [Types::HLSTimestampRange]
+    #
+    # @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-archived-media-2017-09-30/HLSFragmentSelector AWS API Documentation
+    #
+    class HLSFragmentSelector < Struct.new(
+      :fragment_selector_type,
+      :timestamp_range)
+      include Aws::Structure
+    end
+
+    # The start and end of the time stamp range for the requested media.
+    #
+    # This value should not be present if `PlaybackType` is `LIVE`.
+    #
+    # <note markdown="1"> The values in the `HLSTimestampRange` 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 HLSTimestampRange
+    #   data as a hash:
+    #
+    #       {
+    #         start_timestamp: Time.now,
+    #         end_timestamp: Time.now,
+    #       }
+    #
+    # @!attribute [rw] start_timestamp
+    #   The start of the time stamp range for the requested media.
+    #
+    #   If the `HLSTimestampRange` 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 time stamp 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.
+    #
+    #   If the `HLSTimestampRange` value is specified, the `EndTimestamp`
+    #   value is required.
+    #
+    #   <note markdown="1"> This value is inclusive. The `EndTimestamp` is compared to the
+    #   (starting) time stamp 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/HLSTimestampRange AWS API Documentation
+    #
+    class HLSTimestampRange < Struct.new(
+      :start_timestamp,
+      :end_timestamp)
+      include Aws::Structure
+    end
+
     # @note When making an API call, you may pass ListFragmentsInput
     #   data as a hash:
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-sdk-kinesisvideoarchivedmedia
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Amazon Web Services
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-26 00:00:00.000000000 Z
+date: 2018-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-core