W3C

getusermedia: Getting access to local devices that can generate multimedia streams

W3C Editor's Draft 27 April 2012

This version:
http://dev.w3.org/2011/webrtc/editor/getusermedia-20120427.html
Latest published version:
http://www.w3.org/TR/getusermedia/
Latest editor's draft:
http://dev.w3.org/2011/webrtc/editor/getusermedia.html
Previous version:
http://dev.w3.org/2011/webrtc/editor/getusermedia-20111222.html
Editors:
Daniel C. Burnett, Voxeo
Anant Narayanan, Mozilla

Abstract

This document defines a set of APIs that allow local media, including audio and video, to be requested from a platform.

Status of This Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

This document is not complete. It is subject to major changes and, while early experimentations are encouraged, it is therefore not intended for implementation. The API is based on preliminary work done in the WHATWG. The Media Capture Task Force expects this specification to evolve significantly based on:

This document was published by the Media Capture TF as an Editor's Draft. If you wish to make comments regarding this document, please send them to public-media-capture@w3.org (subscribe, archives). All feedback is welcome.

Publication as an Editor's Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

Table of Contents

1. Introduction

This section is non-normative.

Access to multimedia streams (video, audio, or both) from local devices (video cameras, microphones, Web cams) can have a number of uses, such as real-time communication, recording, surveillance.

This document defines the APIs used to get access to local devices (video cameras, microphones, Web cams) that can generate multimedia stream data. This document also defines the stream API by which JavaScript is able to manipulate the stream data or otherwise process it.

2. Stream API

2.1 Introduction

The MediaStream interface is used to represent streams of media data, typically (but not necessarily) of audio and/or video content, e.g. from a local camera. The data from a MediaStream object does not necessarily have a canonical binary form; for example, it could just be "the video currently coming from the user’s video camera". This allows user agents to manipulate media streams in whatever fashion is most suitable on the user’s platform.

Each MediaStream object can contain zero or more tracks, in particular audio and video tracks. All tracks in a MediaStream are intended to be synchronized when rendered. Different MediaStreams do not need to be synchronized.

Each track in a MediaStream object has a corresponding MediaStreamTrack object.

A MediaStreamTrack represents content comprising one or more channels, where the channels have a defined well known relationship to each other (such as a stereo or 5.1 audio signal).

A channel is the smallest unit considered in this API specification.

A MediaStream object has an input and an output. The input depends on how the object was created: a LocalMediaStream object generated by a getUserMedia() call (which is described later in this document), for instance, might take its input from the user’s local camera. The output of the object controls how the object is used, e.g. what is saved if the object is written to a file, what is displayed if the object is used in a video element

Each track in a MediaStream object can be disabled, meaning that it is muted in the object’s output. All tracks are initially enabled.

A MediaStream can be finished, indicating that its inputs have forever stopped providing data.

The output of a MediaStream object must correspond to the tracks in its input. Muted audio tracks must be replaced with silence. Muted video tracks must be replaced with blackness.

A new MediaStream object can be created from existing MediaStreamTrack objects using the MediaStream() constructor. The constructor takes two lists of MediaStreamTrack objects as arguments; one for audio tracks and one for video tracks. The lists can either be the track lists of another stream, subsets of such lists, or compositions of MediaStreamTrack objects from different MediaStream objects.

The ability to duplicate a MediaStream, i.e. create a new MediaStream object from the track lists of an existing stream, allows for greater control since separate MediaStream instances can be manipulated and consumed individually.

The LocalMediaStream interface is used when the user agent is generating the stream’s data (e.g. from a camera or streaming it from a local video file).

When a LocalMediaStream object is being generated from a local file (as opposed to a live audio/video source), the user agent should stream the data from the file in real time, not all at once. The MediaStream object is also used in contexts outside getUserMedia, such as [WEBRTC10]. Hence ensuring a realtime stream in both cases, reduces the ease with which pages can distinguish live video from pre-recorded video, which can help protect the user’s privacy.

2.2 MediaStream

The MediaStream() constructor takes two arguments. The arguments are two lists with MediaStreamTrack objects which will be used to construct the audio and video track lists of the new MediaStream object. When the constructor is invoked, the UA must run the following steps:

  1. Let audioTracks be the constructor’s first argument.

  2. Let videoTracks be the constructor’s second argument.

  3. Let stream be a newly constructed MediaStream object.

  4. Set stream’s label attribute to a newly generated value.

  5. If audioTracks is not null, then run the following sub steps for each element track in audioTracks:

    1. If track is of any other kind than "audio", then throw a SyntaxError exception.

    2. If track has the same underlying source as another element in stream’s audio track list, then abort these steps.

    3. Add track to stream’s audio track list.

  6. If videoTracks is not null, then run the following sub steps for each element track in videoTracks:

    1. If track is of any other kind than "video", then throw a SyntaxError exception.

    2. If track has the same underlying source as another element in stream’s video track list, then abort these steps.

    3. Add track to stream’s video track list.

A MediaStream can have multiple audio and video sources (e.g. because the user has multiple microphones, or because the real source of the stream is a media resource with many media tracks). The stream represented by a MediaStream thus has zero or more tracks.

The tracks of a MediaStream are stored in two track lists represented by MediaStreamTrackList objects; one for audio tracks and one for video tracks. The two track lists must contain the MediaStreamTrack objects that correspond to the tracks of the stream. The relative order of all tracks in a user agent must be stable. Tracks that come from a media resource whose format defines an order must be in the order defined by the format; tracks that come from a media resource whose format does not define an order must be in the relative order in which the tracks are declared in that media resource. Within these constraints, the order is user-agent defined.

An object that reads data from the output of a MediaStream is referred to as a MediaStream consumer. The list of MediaStream consumers currently includes the media elements, PeerConnection (specified in [WEBRTC10]).

MediaStream consumers must be able to handle tracks being added and removed. This behavior is specified per consumer.

A MediaStream object is said to be finished when all tracks belonging to the stream have ended. When this happens for any reason other than the stop() method being invoked, the user agent must queue a task that runs the following steps:

  1. If the object’s ended attribute has the value true already, then abort these steps. (The stop() method was probably called just before the stream stopped for other reasons, e.g. the user clicked an in-page stop button and then the user-agent-provided stop button.)

  2. Set the object’s ended attribute to true.

  3. Fire a simple event named ended at the object.

If the end of the stream was reached due to a user request, the task source for this task is the user interaction task source. Otherwise the task source for this task is the networking task source.

[Constructor (MediaStreamTrackList? audioTracks, MediaStreamTrackList? videoTracks)]
interface MediaStream {
    readonly attribute DOMString            label;
    readonly attribute MediaStreamTrackList audioTracks;
    readonly attribute MediaStreamTrackList videoTracks;
             attribute boolean              ended;
             attribute Function?            onended;
};

2.2.1 Attributes

audioTracks of type MediaStreamTrackList, readonly

Returns a MediaStreamTrackList object representing the audio tracks that can be enabled and disabled.

The audioTracks attribute must return an array host object for objects of type MediaStreamTrack that is fixed length and read only. The same object must be returned each time the attribute is accessed.

ended of type boolean

The MediaStream.ended attribute must return true if the MediaStream has finished, and false otherwise.

When a MediaStream object is created, its ended attribute must be set to false, unless it is being created using the MediaStream() constructor whose arguments are lists of MediaStreamTrack objects that are all ended, in which case the MediaStream object must be created with its ended attribute set to true.

label of type DOMString, readonly

When a LocalMediaStream object is created, the user agent must generate a globally unique identifier string, and must initialize the object’s label attribute to that string. Such strings must only use characters in the ranges U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E, U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E, and must be 36 characters long.

When a MediaStream is created from another using the MediaStream() constructor, the label attribute is initialized to a newly generated value.

The label attribute must return the value to which it was initialized when the object was created.

onended of type Function, nullable
This event handler, of type ended, must be supported by all objects implementing the MediaStream interface.
videoTracks of type MediaStreamTrackList, readonly

Returns a MediaStreamTrackList object representing the video tracks that can be enabled and disabled.

The videoTracks attribute must return an array host object for objects of type MediaStreamTrack that is fixed length and read only. The same object must be returned each time the attribute is accessed.

MediaStream implements EventTarget;

All instances of the MediaStream type are defined to also implement the EventTarget interface.

2.3 LocalMediaStream

Before the web application can access the users media input devices it must let getUserMedia() create a LocalMediaStream. Once the application is done using, e.g., a webcam and a microphone, it may revoke its own access by calling stop() on the LocalMediaStream .

A web application may, once it has access to a LocalMediaStream, use the MediaStream() constructor to construct additional MediaStream objects. Since a derived MediaStream object is created from the tracks of an existing stream, it cannot use any media input devices that have not been approved by the user.

interface LocalMediaStream : MediaStream {
    void stop ();
};

2.3.1 Methods

stop

When a LocalMediaStream object’s stop() method is invoked, the user agent must queue a task that runs the following steps on every track:

  1. Let track be the current MediaStreamTrack object.

  2. End track. The track start outputting only silence and/or blackness, as appropriate.

  3. Dereference track’s underlying media source.

  4. If the reference count of track’s underlying media source is greater than zero, then abort these steps.

  5. Permanently stop the generation of data for track’s source. If the data is being generated from a live source (e.g. a microphone or camera), then the user agent should remove any active "on-air" indicator for that source. If the data is being generated from a prerecorded source (e.g. a video file), any remaining content in the file is ignored.

The task source for the tasks queued for the stop() method is the DOM manipulation task source.

No parameters.
Return type: void

2.4 MediaStreamTrack

A MediaStreamTrack object represents a media source in the user agent. Several MediaStreamTrack objects can represent the same media source, e.g., when the user chooses the same camera in the UI shown by two consecutive calls to getUserMedia().

A MediaStreamTrack object can reference its media source in two ways, either with a strong or a weak reference, depending on how the track was created. For example, a track in a MediaStream, derived from a LocalMediaStream with the MediaStream() constructor, has a weak reference to a local media source, while a track in a LocalMediaStream has a strong reference. This means that a track in a MediaStream, derived from a LocalMediaStream, will end if there is no non-ended track in a LocalMediaStream which references the same local media source.

The concept with strong and weak references to media sources allows the web application to derive new MediaStream objects from LocalMediaStream objects (created via getUserMedia()), and still be able to revoke all given permissions with LocalMediaStream.stop().

A MediaStreamTrack object is said to end when the user agent learns that no more data will ever be forthcoming for this track.

When a MediaStreamTrack object ends for any reason (e.g. because the user rescinds the permission for the page to use the local camera, or because the data comes from a finite file and the file’s end has been reached and the user has not requested that it be looped, or because the UA has instructed the track to end for any reason, or because the reference count of the track’s underlying media source has reached zero, it is said to be ended. When track instance track ends for any reason other than stop() method being invoked on the LocalMediaStream object that represents track, the user agent must queue a task that runs the following steps:

  1. If the track’s readyState attribute has the value ENDED (2) already, then abort these steps.

  2. Set track’s readyState attribute to ENDED (2).

  3. Fire a simple event named ended at the object.

If the end of the stream was reached due to a user request, the event source for this event is the user interaction event source.

interface MediaStreamTrack {
    readonly attribute DOMString      kind;
    readonly attribute DOMString      label;
             attribute boolean        enabled;
    const unsigned short LIVE = 0;
    const unsigned short MUTED = 1;
    const unsigned short ENDED = 2;
    readonly attribute unsigned short readyState;
             attribute Function?      onmute;
             attribute Function?      onunmute;
             attribute Function?      onended;
};

2.4.1 Attributes

enabled of type boolean

The MediaStreamTrack.enabled attribute, on getting, must return the last value to which it was set. On setting, it must be set to the new value, and then, if the MediaStreamTrack object is still associated with a track, must enable the track if the new value is true, and disable it otherwise.

Thus, after a MediaStreamTrack is disassociated from its track, its enabled attribute still changes value when set, it just doesn’t do anything with that new value.

kind of type DOMString, readonly

The MediaStreamTrack.kind attribute must return the string "audio" if the object’s corresponding track is or was an audio track, "video" if the corresponding track is or was a video track, and a user-agent defined string otherwise.

label of type DOMString, readonly

User agents may label audio and video sources (e.g. "Internal microphone" or "External USB Webcam"). The MediaStreamTrack.label attribute must return the label of the object’s corresponding track, if any. If the corresponding track has or had no label, the attribute must instead return the empty string.

Thus the kind and label attributes do not change value, even if the MediaStreamTrack object is disassociated from its corresponding track.

onended of type Function, nullable
This event handler, of type ended, must be supported by all objects implementing the MediaStreamTrack interface.
onmute of type Function, nullable
This event handler, of type muted, must be supported by all objects implementing the MediaStreamTrack interface.
onunmute of type Function, nullable
This event handler, of type unmuted, must be supported by all objects implementing the MediaStreamTrack interface.
readyState of type unsigned short, readonly

The readyState attribute represents the state of the track. It must return the value to which the user agent last set it (as defined below). It can have the following values: LIVE, MUTED or ENDED.

When a MediaStreamTrack object is created, its readyState is either LIVE (0) or MUTED (1), depending on the state of the track’s underlying media source. For example, a track in a LocalMediaStream, created with getUserMedia() , must initially have its readyState attribute set to LIVE (1).

2.4.2 Constants

ENDED of type unsigned short

The track has ended (the track’s underlying media source is no longer providing data, and will never provide more data for this track).

For example, a video track in a LocalMediaStream finishes if the user unplugs the USB web camera that acts as the track’s media source.

LIVE of type unsigned short

The track is active (the track’s underlying media source is making a best-effort attempt to provide data in real time).

The output of a track in the LIVE state can be switched on and off with the enabled attribute.

MUTED of type unsigned short

The track is muted (the track’s underlying media source is temporarily unable to provide data).

A MediaStreamTrack in a LocalMediaStream may be muted if the user temporarily revokes the web application’s permission to use a media input device.

2.5 URL

partial interface URL {
    static DOMString createObjectURL (MediaStream stream);
};

2.5.1 Methods

createObjectURL

Mints a Blob URL to refer to the given MediaStream.

When the createObjectURL() method is called with a MediaStream argument, the user agent must return a unique Blob URL for the given MediaStream. [FILE-API]

For audio and video streams, the data exposed on that stream must be in a format supported by the user agent for use in audio and video elements.

A Blob URL is the same as what the File API specification calls a Blob URI, except that anything in the definition of that feature that refers to File and Blob objects is hereby extended to also apply to MediaStream and LocalMediaStream objects.

ParameterTypeNullableOptionalDescription
streamMediaStream
Return type: static DOMString

2.6 MediaStreamTrackList

A MediaStreamTrackList object’s corresponding MediaStream refers to the MediaStream object which the current MediaStreamTrackList object is a property of.

interface MediaStreamTrackList {
    readonly attribute unsigned long length;
    MediaStreamTrack item (unsigned long index);
    void             add (MediaStreamTrack track);
    void             remove (MediaStreamTrack track);
             attribute Function?     onaddtrack;
             attribute Function?     onremovetrack;
};

2.6.1 Attributes

length of type unsigned long, readonly
Returns the number of tracks in the list.
onaddtrack of type Function, nullable
This event handler, of type addtrack, must be supported by all objects implementing the MediaStreamTrackList interface.
onremovetrack of type Function, nullable
This event handler, of type removetrack, must be supported by all objects implementing the MediaStreamTrackList interface.

2.6.2 Methods

add

Adds the given MediaStreamTrack to this MediaStreamTrackList according to the ordering rules for tracks.

When the add() method is invoked, the user agent must run the following steps:

  1. Let track be the MediaStreamTrack argument.

  2. Let stream be the MediaStreamTrackList object’s corresponding MediaStream object.

  3. If stream is finished, throw an INVALID_STATE_ERR exception.

  4. If track is already in the MediaStreamTrackList, object’s internal list, then abort these steps.

  5. Add track to the end of the MediaStreamTrackList object’s internal list.

ParameterTypeNullableOptionalDescription
trackMediaStreamTrack
Return type: void
item
Returns the MediaStreamTrack object at the specified index.
ParameterTypeNullableOptionalDescription
indexunsigned long
Return type: MediaStreamTrack
remove

Removes the given MediaStreamTrack from this MediaStreamTrackList.

When the remove() method is invoked, the user agent must run the following steps:

  1. Let track be the MediaStreamTrack argument.

  2. Let stream be the MediaStreamTrackList object’s corresponding MediaStream object.

  3. If stream is finished, throw an INVALID_STATE_ERR exception.

  4. If track is not in the MediaStreamTrackList, object’s internal list, then abort these steps.

  5. Remove track from the MediaStreamTrackList object’s internal list.

ParameterTypeNullableOptionalDescription
trackMediaStreamTrack
Return type: void

3. Obtaining local multimedia content

3.2 MediaStreamOptions

dictionary MediaStreamOptions {
    boolean audio;
    boolean video;
};

3.2.1 Dictionary MediaStreamOptions Members

audio of type boolean
Set to true if an audio track is requested, default is false
video of type boolean
Set to true if a video track is requested, default is false

4. Examples

This sample code exposes a button. When clicked, the button is disabled and the user is prompted to offer a stream. The user can cause the button to be re-enabled by providing a stream (e.g. giving the page access to the local camera) and then disabling the stream (e.g. revoking that access).

<input type="button" value="Start" onclick="start()" id="startBtn">
<script>
 var startBtn = document.getElementById('startBtn');
 function start() {
   navigator.getUserMedia({audio:true, video:true}, gotStream);
   startBtn.disabled = true;
 }
 function gotStream(stream) {
   stream.onended = function () {
     startBtn.disabled = false;
   }
 }
</script>

This example allows people to take photos of themselves from the local video camera.

<article>
 <style scoped>
  video { transform: scaleX(-1); }
  p { text-align: center; }
 </style>
 <h1>Snapshot Kiosk</h1>
 <section id="splash">
  <p id="errorMessage">Loading...</p>
 </section>
 <section id="app" hidden>
  <p><video id="monitor" autoplay></video> <canvas id="photo"></canvas>
  <p><input type=button value="&#x1F4F7;" onclick="snapshot()">
 </section>
 <script>
  navigator.getUserMedia({video:true}, gotStream, noStream);
  var video = document.getElementById('monitor');
  var canvas = document.getElementById('photo');
  function gotStream(stream) {
    video.src = URL.createObjectURL(stream);
    video.onerror = function () {
      stream.stop();
    };
    stream.onended = noStream;
    video.onloadedmetadata = function () {
      canvas.width = video.videoWidth;
      canvas.height = video.videoHeight;
      document.getElementById('splash').hidden = true;
      document.getElementById('app').hidden = false;
    };
  }
  function noStream() {
    document.getElementById('errorMessage').textContent = 'No camera available.';
  }
  function snapshot() {
    canvas.getContext('2d').drawImage(video, 0, 0);
  }
 </script>
</article>

5. Garbage collection

6. Event definitions

7. Event summary

This section is non-normative.

8. Change Log

This section will be removed before publication.

To Do Items

-

Apr 23 2012

  1. Remove MediaStreamRecorder.

Apr 20 2012

  1. Add definitions of MediaStreams and related objects.

Dec 21 2011

  1. Changed to make wanted media opt in (rather than opt out). Minor edits.

Nov 29 2011

  1. Changed examples to use MediaStreamOptions objects rather than strings. Minor edits.

Nov 15 2011

  1. Removed MediaStream stuff. Refers to webrtc 1.0 spec for that part instead.

Nov 9 2011

  1. Created first version by copying the webrtc spec and ripping out stuff. Put it on github.

A. Acknowledgements

B. References

B.1 Normative references

[FILE-API]
Arun Ranganathan; Jonas Sicking. File API. 20 October 2011. W3C Working Draft. (Work in progress.) URL: http://www.w3.org/TR/2011/WD-FileAPI-20111020/
[WEBRTC10]
A Bergkvist; D Burnett; C Jennings; A Narayanan. WebRTC 1.0. 27 October 2011. W3C Working Draft. (Work in progress.) URL: http://www.w3.org/TR/2011/WD-webrtc-20111027/

B.2 Informative references

No informative references.