/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * * Licensed under the Apache License, Version 2.0 (the "License"). * You may not use this file except in compliance with the License. * A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. This file is distributed * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. See the License for the specific language governing * permissions and limitations under the License. */ /* * Do not modify this file. This file is generated from the kinesis-video-archived-media-2017-09-30.normal.json service model. */ using System; using System.Collections.Generic; using System.Xml.Serialization; using System.Text; using System.IO; using System.Net; using Amazon.Runtime; using Amazon.Runtime.Internal; namespace Amazon.KinesisVideoArchivedMedia.Model { /// /// Container for the parameters to the GetDASHStreamingSessionURL operation. /// 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 following procedure shows how to use MPEG-DASH with Kinesis Video Streams: /// ///
  1. /// /// Get an endpoint using GetDataEndpoint, /// 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). /// /// /// /// Don't share or store this token where an unauthorized entity can access it. The token /// provides access to the content of the stream. Safeguard the token with the same measures /// that you use with your AWS credentials. /// /// /// /// 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. /// /// /// /// 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. /// /// /// /// Data retrieved with this action is billable. See Pricing /// for details. /// ///
/// /// For restrictions that apply to MPEG-DASH sessions, see Kinesis /// Video Streams Limits. /// /// /// /// 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. For pricing information, see Amazon /// Kinesis Video Streams Pricing and AWS /// Pricing. Charges for both HLS sessions and outgoing AWS data apply. /// /// /// /// For more information about HLS, see HTTP /// Live Streaming on the Apple Developer site. /// /// /// /// 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: /// /// /// /// 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. /// /// /// public partial class GetDASHStreamingSessionURLRequest : AmazonKinesisVideoArchivedMediaRequest { private DASHFragmentSelector _dashFragmentSelector; private DASHDisplayFragmentNumber _displayFragmentNumber; private DASHDisplayFragmentTimestamp _displayFragmentTimestamp; private int? _expires; private long? _maxManifestFragmentResults; private DASHPlaybackMode _playbackMode; private string _streamARN; private string _streamName; /// /// Gets and sets the property DASHFragmentSelector. /// /// 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. /// /// public DASHFragmentSelector DASHFragmentSelector { get { return this._dashFragmentSelector; } set { this._dashFragmentSelector = value; } } // Check to see if DASHFragmentSelector property is set internal bool IsSetDASHFragmentSelector() { return this._dashFragmentSelector != null; } /// /// Gets and sets the property DisplayFragmentNumber. /// /// 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. /// /// public DASHDisplayFragmentNumber DisplayFragmentNumber { get { return this._displayFragmentNumber; } set { this._displayFragmentNumber = value; } } // Check to see if DisplayFragmentNumber property is set internal bool IsSetDisplayFragmentNumber() { return this._displayFragmentNumber != null; } /// /// Gets and sets the property DisplayFragmentTimestamp. /// /// 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. /// /// /// public DASHDisplayFragmentTimestamp DisplayFragmentTimestamp { get { return this._displayFragmentTimestamp; } set { this._displayFragmentTimestamp = value; } } // Check to see if DisplayFragmentTimestamp property is set internal bool IsSetDisplayFragmentTimestamp() { return this._displayFragmentTimestamp != null; } /// /// Gets and sets the property 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). /// /// [AWSProperty(Min=300, Max=43200)] public int Expires { get { return this._expires.GetValueOrDefault(); } set { this._expires = value; } } // Check to see if Expires property is set internal bool IsSetExpires() { return this._expires.HasValue; } /// /// Gets and sets the property MaxManifestFragmentResults. /// /// 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. /// /// [AWSProperty(Min=1, Max=5000)] public long MaxManifestFragmentResults { get { return this._maxManifestFragmentResults.GetValueOrDefault(); } set { this._maxManifestFragmentResults = value; } } // Check to see if MaxManifestFragmentResults property is set internal bool IsSetMaxManifestFragmentResults() { return this._maxManifestFragmentResults.HasValue; } /// /// Gets and sets the property PlaybackMode. /// /// Whether to retrieve live, live replay, or archived, on-demand data. /// /// /// /// Features of the three types of sessions include the following: /// /// /// /// 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. /// /// public DASHPlaybackMode PlaybackMode { get { return this._playbackMode; } set { this._playbackMode = value; } } // Check to see if PlaybackMode property is set internal bool IsSetPlaybackMode() { return this._playbackMode != null; } /// /// Gets and sets the property StreamARN. /// /// 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. /// /// [AWSProperty(Min=1, Max=1024)] public string StreamARN { get { return this._streamARN; } set { this._streamARN = value; } } // Check to see if StreamARN property is set internal bool IsSetStreamARN() { return this._streamARN != null; } /// /// Gets and sets the property StreamName. /// /// The name of the stream for which to retrieve the MPEG-DASH manifest URL. /// /// /// /// You must specify either the StreamName or the StreamARN. /// /// [AWSProperty(Min=1, Max=256)] public string StreamName { get { return this._streamName; } set { this._streamName = value; } } // Check to see if StreamName property is set internal bool IsSetStreamName() { return this._streamName != null; } } }