media/cast/cast_config.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MEDIA_CAST_CAST_CONFIG_H_
   6 #define MEDIA_CAST_CAST_CONFIG_H_
   7
   8 #include <list>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/callback.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/shared_memory.h"
  16 #include "base/single_thread_task_runner.h"
  17 #include "base/time/time.h"
  18 #include "media/cast/cast_defines.h"
  19 #include "media/cast/net/cast_transport_config.h"
  20
  21 namespace media {
  22 class VideoEncodeAccelerator;
  23
  24 namespace cast {
  25
  26 // TODO(miu): Merge AudioSenderConfig and VideoSenderConfig and make their
  27 // naming/documentation consistent with FrameReceiverConfig.
  28 struct AudioSenderConfig {
  29   AudioSenderConfig();
  30   ~AudioSenderConfig();
  31
  32   // Identifier referring to the sender, used by the receiver.
  33   uint32 ssrc;
  34
  35   // The receiver's SSRC identifier.
  36   uint32 receiver_ssrc;
  37
  38   int rtcp_interval;
  39
  40   // The total amount of time between a frame's capture/recording on the sender
  41   // and its playback on the receiver (i.e., shown to a user).  This should be
  42   // set to a value large enough to give the system sufficient time to encode,
  43   // transmit/retransmit, receive, decode, and render; given its run-time
  44   // environment (sender/receiver hardware performance, network conditions,
  45   // etc.).
  46   base::TimeDelta min_playout_delay;
  47   base::TimeDelta max_playout_delay;
  48
  49   // RTP payload type enum: Specifies the type/encoding of frame data.
  50   int rtp_payload_type;
  51
  52   bool use_external_encoder;
  53   int frequency;
  54   int channels;
  55   int bitrate;  // Set to <= 0 for "auto variable bitrate" (libopus knows best).
  56   Codec codec;
  57
  58   // The AES crypto key and initialization vector.  Each of these strings
  59   // contains the data in binary form, of size kAesKeySize.  If they are empty
  60   // strings, crypto is not being used.
  61   std::string aes_key;
  62   std::string aes_iv_mask;
  63 };
  64
  65 struct VideoSenderConfig {
  66   VideoSenderConfig();
  67   ~VideoSenderConfig();
  68
  69   // Identifier referring to the sender, used by the receiver.
  70   uint32 ssrc;
  71
  72   // The receiver's SSRC identifier.
  73   uint32 receiver_ssrc;
  74
  75   int rtcp_interval;
  76
  77   // The total amount of time between a frame's capture/recording on the sender
  78   // and its playback on the receiver (i.e., shown to a user).  This should be
  79   // set to a value large enough to give the system sufficient time to encode,
  80   // transmit/retransmit, receive, decode, and render; given its run-time
  81   // environment (sender/receiver hardware performance, network conditions,
  82   // etc.).
  83   base::TimeDelta min_playout_delay;
  84   base::TimeDelta max_playout_delay;
  85
  86   // RTP payload type enum: Specifies the type/encoding of frame data.
  87   int rtp_payload_type;
  88
  89   bool use_external_encoder;
  90   int width;  // Incoming frames will be scaled to this size.
  91   int height;
  92
  93   float congestion_control_back_off;
  94   int max_bitrate;
  95   int min_bitrate;
  96   int start_bitrate;
  97   int max_qp;
  98   int min_qp;
  99   int max_frame_rate;  // TODO(miu): Should be double, not int.
 100
 101   // This field is used differently by various encoders. It defaults to 1.
 102   //
 103   // For VP8, it should be 1 to operate in single-buffer mode, or 3 to operate
 104   // in multi-buffer mode. See
 105   // http://www.webmproject.org/docs/encoder-parameters/ for details.
 106   //
 107   // For H.264 on Mac or iOS, it controls the max number of frames the encoder
 108   // may hold before emitting a frame. A larger window may allow higher encoding
 109   // efficiency at the cost of latency and memory. Set to 0 to let the encoder
 110   // choose a suitable value for the platform and other encoding settings.
 111   int max_number_of_video_buffers_used;
 112
 113   Codec codec;
 114   int number_of_encode_threads;
 115
 116   // The AES crypto key and initialization vector.  Each of these strings
 117   // contains the data in binary form, of size kAesKeySize.  If they are empty
 118   // strings, crypto is not being used.
 119   std::string aes_key;
 120   std::string aes_iv_mask;
 121 };
 122
 123 // TODO(miu): Naming and minor type changes are badly needed in a later CL.
 124 struct FrameReceiverConfig {
 125   FrameReceiverConfig();
 126   ~FrameReceiverConfig();
 127
 128   // The receiver's SSRC identifier.
 129   uint32 feedback_ssrc;  // TODO(miu): Rename to receiver_ssrc for clarity.
 130
 131   // The sender's SSRC identifier.
 132   uint32 incoming_ssrc;  // TODO(miu): Rename to sender_ssrc for clarity.
 133
 134   // Mean interval (in milliseconds) between RTCP reports.
 135   // TODO(miu): Remove this since it's never not kDefaultRtcpIntervalMs.
 136   int rtcp_interval;
 137
 138   // The total amount of time between a frame's capture/recording on the sender
 139   // and its playback on the receiver (i.e., shown to a user).  This is fixed as
 140   // a value large enough to give the system sufficient time to encode,
 141   // transmit/retransmit, receive, decode, and render; given its run-time
 142   // environment (sender/receiver hardware performance, network conditions,
 143   // etc.).
 144   int rtp_max_delay_ms;  // TODO(miu): Change to TimeDelta target_playout_delay.
 145
 146   // RTP payload type enum: Specifies the type/encoding of frame data.
 147   int rtp_payload_type;
 148
 149   // RTP timebase: The number of RTP units advanced per one second.  For audio,
 150   // this is the sampling rate.  For video, by convention, this is 90 kHz.
 151   int rtp_timebase;
 152
 153   // Number of channels.  For audio, this is normally 2.  For video, this must
 154   // be 1 as Cast does not have support for stereoscopic video.
 155   int channels;
 156
 157   // The target frame rate.  For audio, this is normally 100 (i.e., frames have
 158   // a duration of 10ms each).  For video, this is normally 30, but any frame
 159   // rate is supported.
 160   int target_frame_rate;
 161
 162   // Codec used for the compression of signal data.
 163   // TODO(miu): Merge the AudioCodec and VideoCodec enums into one so this union
 164   // is not necessary.
 165   Codec codec;
 166
 167   // The AES crypto key and initialization vector.  Each of these strings
 168   // contains the data in binary form, of size kAesKeySize.  If they are empty
 169   // strings, crypto is not being used.
 170   std::string aes_key;
 171   std::string aes_iv_mask;
 172 };
 173
 174 // Import from media::cast.
 175
 176 typedef Packet Packet;
 177 typedef PacketList PacketList;
 178
 179 // Callback that is run to update the client with current status.  This is used
 180 // to allow the client to wait for asynchronous initialization to complete
 181 // before sending frames, and also to be notified of any runtime errors that
 182 // have halted the session.
 183 typedef base::Callback<void(OperationalStatus)> StatusChangeCallback;
 184
 185 typedef base::Callback<void(scoped_refptr<base::SingleThreadTaskRunner>,
 186                             scoped_ptr<media::VideoEncodeAccelerator>)>
 187     ReceiveVideoEncodeAcceleratorCallback;
 188 typedef base::Callback<void(const ReceiveVideoEncodeAcceleratorCallback&)>
 189     CreateVideoEncodeAcceleratorCallback;
 190
 191 typedef base::Callback<void(scoped_ptr<base::SharedMemory>)>
 192     ReceiveVideoEncodeMemoryCallback;
 193 typedef base::Callback<void(size_t size,
 194                             const ReceiveVideoEncodeMemoryCallback&)>
 195     CreateVideoEncodeMemoryCallback;
 196
 197 }  // namespace cast
 198 }  // namespace media
 199
 200 #endif  // MEDIA_CAST_CAST_CONFIG_H_