content/public/common/media_stream_request.h

   1 // Copyright (c) 2012 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 CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
   6 #define CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/callback_forward.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "content/common/content_export.h"
  16 #include "ui/gfx/native_widget_types.h"
  17 #include "url/gurl.h"
  18
  19 namespace content {
  20
  21 // Types of media streams.
  22 enum MediaStreamType {
  23   MEDIA_NO_SERVICE = 0,
  24
  25   // A device provided by the operating system (e.g., webcam input).
  26   MEDIA_DEVICE_AUDIO_CAPTURE,
  27   MEDIA_DEVICE_VIDEO_CAPTURE,
  28
  29   // Mirroring of a browser tab.
  30   MEDIA_TAB_AUDIO_CAPTURE,
  31   MEDIA_TAB_VIDEO_CAPTURE,
  32
  33   // Desktop media sources.
  34   MEDIA_DESKTOP_VIDEO_CAPTURE,
  35
  36   // Capture system audio (post-mix loopback stream).
  37   //
  38   // TODO(sergeyu): Replace with MEDIA_DESKTOP_AUDIO_CAPTURE.
  39   MEDIA_LOOPBACK_AUDIO_CAPTURE,
  40
  41   NUM_MEDIA_TYPES
  42 };
  43
  44 // Types of media stream requests that can be made to the media controller.
  45 enum MediaStreamRequestType {
  46   MEDIA_DEVICE_ACCESS = 0,
  47   MEDIA_GENERATE_STREAM,
  48   MEDIA_ENUMERATE_DEVICES,
  49   MEDIA_OPEN_DEVICE  // Only used in requests made by Pepper.
  50 };
  51
  52 // Facing mode for video capture.
  53 enum VideoFacingMode {
  54   MEDIA_VIDEO_FACING_NONE = 0,
  55   MEDIA_VIDEO_FACING_USER,
  56   MEDIA_VIDEO_FACING_ENVIRONMENT,
  57   MEDIA_VIDEO_FACING_LEFT,
  58   MEDIA_VIDEO_FACING_RIGHT,
  59
  60   NUM_MEDIA_VIDEO_FACING_MODE
  61 };
  62
  63 enum MediaStreamRequestResult {
  64   MEDIA_DEVICE_OK = 0,
  65   MEDIA_DEVICE_PERMISSION_DENIED,
  66   MEDIA_DEVICE_PERMISSION_DISMISSED,
  67   MEDIA_DEVICE_INVALID_STATE,
  68   MEDIA_DEVICE_NO_HARDWARE,
  69   MEDIA_DEVICE_INVALID_SECURITY_ORIGIN,
  70   MEDIA_DEVICE_TAB_CAPTURE_FAILURE,
  71   MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE,
  72   MEDIA_DEVICE_CAPTURE_FAILURE,
  73   MEDIA_DEVICE_TRACK_START_FAILURE,
  74
  75   NUM_MEDIA_REQUEST_RESULTS
  76 };
  77
  78 // Convenience predicates to determine whether the given type represents some
  79 // audio or some video device.
  80 CONTENT_EXPORT bool IsAudioMediaType(MediaStreamType type);
  81 CONTENT_EXPORT bool IsVideoMediaType(MediaStreamType type);
  82
  83 // TODO(xians): Change the structs to classes.
  84 // Represents one device in a request for media stream(s).
  85 struct CONTENT_EXPORT MediaStreamDevice {
  86   MediaStreamDevice();
  87
  88   MediaStreamDevice(
  89       MediaStreamType type,
  90       const std::string& id,
  91       const std::string& name);
  92
  93   MediaStreamDevice(
  94       MediaStreamType type,
  95       const std::string& id,
  96       const std::string& name,
  97       int sample_rate,
  98       int channel_layout,
  99       int frames_per_buffer);
 100
 101   ~MediaStreamDevice();
 102
 103   bool IsEqual(const MediaStreamDevice& second) const;
 104
 105   // The device's type.
 106   MediaStreamType type;
 107
 108   // The device's unique ID.
 109   std::string id;
 110
 111   // The facing mode for video capture device.
 112   VideoFacingMode video_facing;
 113
 114   // The device id of a matched output device if any (otherwise empty).
 115   // Only applicable to audio devices.
 116   std::string matched_output_device_id;
 117
 118   // The device's "friendly" name. Not guaranteed to be unique.
 119   std::string name;
 120
 121   // Contains properties that match directly with those with the same name
 122   // in media::AudioParameters.
 123   struct AudioDeviceParameters {
 124     AudioDeviceParameters()
 125         : sample_rate(), channel_layout(), frames_per_buffer(), effects() {
 126     }
 127
 128     AudioDeviceParameters(int sample_rate, int channel_layout,
 129         int frames_per_buffer)
 130         : sample_rate(sample_rate),
 131           channel_layout(channel_layout),
 132           frames_per_buffer(frames_per_buffer),
 133           effects() {
 134     }
 135
 136     // Preferred sample rate in samples per second for the device.
 137     int sample_rate;
 138
 139     // Preferred channel configuration for the device.
 140     // TODO(henrika): ideally, we would like to use media::ChannelLayout here
 141     // but including media/base/channel_layout.h violates checkdeps rules.
 142     int channel_layout;
 143
 144     // Preferred number of frames per buffer for the device.  This is filled
 145     // in on the browser side and can be used by the renderer to match the
 146     // expected browser side settings and avoid unnecessary buffering.
 147     // See media::AudioParameters for more.
 148     int frames_per_buffer;
 149
 150     // See media::AudioParameters::PlatformEffectsMask.
 151     int effects;
 152   };
 153
 154   // These below two member variables are valid only when the type of device is
 155   // audio (i.e. IsAudioMediaType returns true).
 156
 157   // Contains the device properties of the capture device.
 158   AudioDeviceParameters input;
 159
 160   // If the capture device has an associated output device (e.g. headphones),
 161   // this will contain the properties for the output device.  If no such device
 162   // exists (e.g. webcam w/mic), then the value of this member will be all
 163   // zeros.
 164   AudioDeviceParameters matched_output;
 165 };
 166
 167 class CONTENT_EXPORT MediaStreamDevices
 168     : public std::vector<MediaStreamDevice> {
 169  public:
 170   MediaStreamDevices();
 171   MediaStreamDevices(size_t count, const MediaStreamDevice& value);
 172
 173   // Looks for a MediaStreamDevice based on its ID.
 174   // Returns NULL if not found.
 175   const MediaStreamDevice* FindById(const std::string& device_id) const;
 176 };
 177
 178 typedef std::map<MediaStreamType, MediaStreamDevices> MediaStreamDeviceMap;
 179
 180 // Represents a request for media streams (audio/video).
 181 // TODO(vrk): Decouple MediaStreamDevice from this header file so that
 182 // media_stream_options.h no longer depends on this file.
 183 // TODO(vrk,justinlin,wjia): Figure out a way to share this code cleanly between
 184 // vanilla WebRTC, Tab Capture, and Pepper Video Capture. Right now there is
 185 // Tab-only stuff and Pepper-only stuff being passed around to all clients,
 186 // which is icky.
 187 struct CONTENT_EXPORT MediaStreamRequest {
 188   MediaStreamRequest(
 189       int render_process_id,
 190       int render_view_id,
 191       int page_request_id,
 192       const GURL& security_origin,
 193       bool user_gesture,
 194       MediaStreamRequestType request_type,
 195       const std::string& requested_audio_device_id,
 196       const std::string& requested_video_device_id,
 197       MediaStreamType audio_type,
 198       MediaStreamType video_type);
 199
 200   ~MediaStreamRequest();
 201
 202   // This is the render process id for the renderer associated with generating
 203   // frames for a MediaStream. Any indicators associated with a capture will be
 204   // displayed for this renderer.
 205   int render_process_id;
 206
 207   // This is the render view id for the renderer associated with generating
 208   // frames for a MediaStream. Any indicators associated with a capture will be
 209   // displayed for this renderer.
 210   int render_view_id;
 211
 212   // The unique id combined with render_process_id and render_view_id for
 213   // identifying this request. This is used for cancelling request.
 214   int page_request_id;
 215
 216   // Used by tab capture.
 217   std::string tab_capture_device_id;
 218
 219   // The WebKit security origin for the current request (e.g. "html5rocks.com").
 220   GURL security_origin;
 221
 222   // Set to true if the call was made in the context of a user gesture.
 223   bool user_gesture;
 224
 225   // Stores the type of request that was made to the media controller. Right now
 226   // this is only used to distinguish between WebRTC and Pepper requests, as the
 227   // latter should not be subject to user approval but only to policy check.
 228   // Pepper requests are signified by the |MEDIA_OPEN_DEVICE| value.
 229   MediaStreamRequestType request_type;
 230
 231   // Stores the requested raw device id for physical audio or video devices.
 232   std::string requested_audio_device_id;
 233   std::string requested_video_device_id;
 234
 235   // Flag to indicate if the request contains audio.
 236   MediaStreamType audio_type;
 237
 238   // Flag to indicate if the request contains video.
 239   MediaStreamType video_type;
 240 };
 241
 242 // Interface used by the content layer to notify chrome about changes in the
 243 // state of a media stream. Instances of this class are passed to content layer
 244 // when MediaStream access is approved using MediaResponseCallback.
 245 class MediaStreamUI {
 246  public:
 247   virtual ~MediaStreamUI() {}
 248
 249   // Called when MediaStream capturing is started. Chrome layer can call |stop|
 250   // to stop the stream. Returns the platform-dependent window ID for the UI, or
 251   // 0 if not applicable.
 252   virtual gfx::NativeViewId OnStarted(const base::Closure& stop) = 0;
 253 };
 254
 255 // Callback used return results of media access requests.
 256 typedef base::Callback<void(
 257     const MediaStreamDevices& devices,
 258     content::MediaStreamRequestResult result,
 259     scoped_ptr<MediaStreamUI> ui)> MediaResponseCallback;
 260
 261 }  // namespace content
 262
 263 #endif  // CONTENT_PUBLIC_COMMON_MEDIA_STREAM_REQUEST_H_