def get_media(params = {}, options = {}, &block)
      req = build_request(:get_media, params)
      req.send_request(options, &block)
    end
def get_media(params = {}, options = {}, &block)
      req = build_request(:get_media, params)
      req.send_request(options, &block)
    end
@overload initialize(options)
   @param [Hash] options
   @option options [required, Aws::CredentialProvider] :credentials
     Your AWS credentials. This can be an instance of any one of the
     following classes:

     * `Aws::Credentials` - Used for configuring static, non-refreshing
       credentials.

     * `Aws::InstanceProfileCredentials` - Used for loading credentials
       from an EC2 IMDS on an EC2 instance.

     * `Aws::SharedCredentials` - Used for loading credentials from a
       shared file, such as `~/.aws/config`.

     * `Aws::AssumeRoleCredentials` - Used when you need to assume a role.

     When `:credentials` are not configured directly, the following
     locations will be searched for credentials:

     * `Aws.config[:credentials]`
     * The `:access_key_id`, `:secret_access_key`, and `:session_token` options.
     * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
     * `~/.aws/credentials`
     * `~/.aws/config`
     * EC2 IMDS instance profile - When used by default, the timeouts are
       very aggressive. Construct and pass an instance of
       `Aws::InstanceProfileCredentails` to enable retries and extended
       timeouts.

   @option options [required, String] :region
     The AWS region to connect to.  The configured `:region` is
     used to determine the service `:endpoint`. When not passed,
     a default `:region` is search for in the following locations:

     * `Aws.config[:region]`
     * `ENV['AWS_REGION']`
     * `ENV['AMAZON_REGION']`
     * `ENV['AWS_DEFAULT_REGION']`
     * `~/.aws/credentials`
     * `~/.aws/config`

   @option options [String] :access_key_id

   @option options [Boolean] :active_endpoint_cache (false)
     When set to `true`, a thread polling for endpoints will be running in
     the background every 60 secs (default). Defaults to `false`.

   @option options [Boolean] :client_side_monitoring (false)
     When `true`, client-side metrics will be collected for all API requests from
     this client.

   @option options [String] :client_side_monitoring_client_id ("")
     Allows you to provide an identifier for this client which will be attached to
     all generated client side metrics. Defaults to an empty string.

   @option options [Integer] :client_side_monitoring_port (31000)
     Required for publishing client metrics. The port that the client side monitoring
     agent is running on, where client metrics will be published via UDP.

   @option options [Aws::ClientSideMonitoring::Publisher] :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher)
     Allows you to provide a custom client-side monitoring publisher class. By default,
     will use the Client Side Monitoring Agent Publisher.

   @option options [Boolean] :convert_params (true)
     When `true`, an attempt is made to coerce request parameters into
     the required types.

   @option options [Boolean] :disable_host_prefix_injection (false)
     Set to true to disable SDK automatically adding host prefix
     to default service endpoint when available.

   @option options [String] :endpoint
     The client endpoint is normally constructed from the `:region`
     option. You should only configure an `:endpoint` when connecting
     to test endpoints. This should be avalid HTTP(S) URI.

   @option options [Integer] :endpoint_cache_max_entries (1000)
     Used for the maximum size limit of the LRU cache storing endpoints data
     for endpoint discovery enabled operations. Defaults to 1000.

   @option options [Integer] :endpoint_cache_max_threads (10)
     Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

   @option options [Integer] :endpoint_cache_poll_interval (60)
     When :endpoint_discovery and :active_endpoint_cache is enabled,
     Use this option to config the time interval in seconds for making
     requests fetching endpoints information. Defaults to 60 sec.

   @option options [Boolean] :endpoint_discovery (false)
     When set to `true`, endpoint discovery will be enabled for operations when available. Defaults to `false`.

   @option options [Aws::Log::Formatter] :log_formatter (Aws::Log::Formatter.default)
     The log formatter.

   @option options [Symbol] :log_level (:info)
     The log level to send messages to the `:logger` at.

   @option options [Logger] :logger
     The Logger instance to send log messages to.  If this option
     is not set, logging will be disabled.

   @option options [String] :profile ("default")
     Used when loading credentials from the shared credentials file
     at HOME/.aws/credentials.  When not specified, 'default' is used.

   @option options [Float] :retry_base_delay (0.3)
     The base delay in seconds used by the default backoff function.

   @option options [Symbol] :retry_jitter (:none)
     A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number.

     @see https://www.awsarchitectureblog.com/2015/03/backoff.html

   @option options [Integer] :retry_limit (3)
     The maximum number of times to retry failed requests.  Only
     ~ 500 level server errors and certain ~ 400 level client errors
     are retried.  Generally, these are throttling errors, data
     checksum errors, networking errors, timeout errors and auth
     errors from expired credentials.

   @option options [Integer] :retry_max_delay (0)
     The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function.

   @option options [String] :secret_access_key

   @option options [String] :session_token

   @option options [Boolean] :stub_responses (false)
     Causes the client to return stubbed responses. By default
     fake responses are generated and returned. You can specify
     the response data to return or errors to raise by calling
     {ClientStubs#stub_responses}. See {ClientStubs} for more information.

     ** Please note ** When response stubbing is enabled, no HTTP
     requests are made, and retries are disabled.

   @option options [Boolean] :validate_params (true)
     When `true`, request parameters are validated before
     sending the request.

   @option options [URI::HTTP,String] :http_proxy A proxy to send
     requests through.  Formatted like 'http://proxy.com:123'.

   @option options [Float] :http_open_timeout (15) The number of
     seconds to wait when opening a HTTP session before rasing a
     `Timeout::Error`.

   @option options [Integer] :http_read_timeout (60) The default
     number of seconds to wait for response data.  This value can
     safely be set
     per-request on the session yeidled by {#session_for}.

   @option options [Float] :http_idle_timeout (5) The number of
     seconds a connection is allowed to sit idble before it is
     considered stale.  Stale connections are closed and removed
     from the pool before making a request.

   @option options [Float] :http_continue_timeout (1) The number of
     seconds to wait for a 100-continue response before sending the
     request body.  This option has no effect unless the request has
     "Expect" header set to "100-continue".  Defaults to `nil` which
     disables this behaviour.  This value can safely be set per
     request on the session yeidled by {#session_for}.

   @option options [Boolean] :http_wire_trace (false) When `true`,
     HTTP debug output will be sent to the `:logger`.

   @option options [Boolean] :ssl_verify_peer (true) When `true`,
     SSL peer certificates are verified when establishing a
     connection.

   @option options [String] :ssl_ca_bundle Full path to the SSL
     certificate authority bundle file that should be used when
     verifying peer certificates.  If you do not pass
     `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default
     will be used if available.

   @option options [String] :ssl_ca_directory Full path of the
     directory that contains the unbundled SSL certificate
     authority files for verifying peer certificates.  If you do
     not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the the
     system default will be used if available.

 @!group API Operations
 Use this API to retrieve media content from a Kinesis video stream. In
 the request, you identify the stream name or stream Amazon Resource
 Name (ARN), and the starting chunk. Kinesis Video Streams then returns
 a stream of chunks in order by fragment number.

 <note markdown="1"> You must first call the `GetDataEndpoint` API to get an endpoint. Then
 send the `GetMedia` requests to this endpoint using the
 [--endpoint-url parameter][1].

  </note>

 When you put media data (fragments) on a stream, Kinesis Video Streams
 stores each incoming fragment and related metadata in what is called a
 "chunk." For more information, see . The `GetMedia` API returns a
 stream of these chunks starting from the chunk that you specify in the
 request.

 The following limits apply when using the `GetMedia` API:

 * A client can call `GetMedia` up to five times per second per stream.

 * Kinesis Video Streams sends media data at a rate of up to 25
   megabytes per second (or 200 megabits per second) during a
   `GetMedia` session.



 [1]: https://docs.aws.amazon.com/cli/latest/reference/

 @option params [String] :stream_name
   The Kinesis video stream name from where you want to get the media
   content. If you don't specify the `streamName`, you must specify the
   `streamARN`.

 @option params [String] :stream_arn
   The ARN of the stream from where you want to get the media content. If
   you don't specify the `streamARN`, you must specify the `streamName`.

 @option params [required, Types::StartSelector] :start_selector
   Identifies the starting chunk to get from the specified stream.

 @return [Types::GetMediaOutput] Returns a {Seahorse::Client::Response response} object which responds to the following methods:

   * {Types::GetMediaOutput#content_type #content_type} => String
   * {Types::GetMediaOutput#payload #payload} => IO

 @example Request syntax with placeholder values

   resp = client.get_media({
     stream_name: "StreamName",
     stream_arn: "ResourceARN",
     start_selector: { # required
       start_selector_type: "FRAGMENT_NUMBER", # required, accepts FRAGMENT_NUMBER, SERVER_TIMESTAMP, PRODUCER_TIMESTAMP, NOW, EARLIEST, CONTINUATION_TOKEN
       after_fragment_number: "FragmentNumberString",
       start_timestamp: Time.now,
       continuation_token: "ContinuationToken",
     },
   })

 @example Response structure

   resp.content_type #=> String
   resp.payload #=> IO

 @see http://docs.aws.amazon.com/goto/WebAPI/kinesis-video-media-2017-09-30/GetMedia AWS API Documentation

 @overload get_media(params = {})
 @param [Hash] params ({})