diff --git a/chrome/chrome.d.ts b/chrome/chrome.d.ts
index 41bea3052..2fc2fb6fc 100755
--- a/chrome/chrome.d.ts
+++ b/chrome/chrome.d.ts
@@ -1822,7 +1822,7 @@ declare module chrome.tabCapture {
         videoConstraints?: MediaTrackConstraints;
     }
 
-    export function capture(options: CaptureOptions, callback: (stream: LocalMediaStream) => void): void;
+    export function capture(options: CaptureOptions, callback: (stream: MediaStream) => void): void;
     export function getCapturedTabs(callback: (result: CaptureInfo[]) => void): void;
 }
 
diff --git a/webaudioapi/waa.d.ts b/webaudioapi/waa.d.ts
index 3ccc78b78..80823700a 100644
--- a/webaudioapi/waa.d.ts
+++ b/webaudioapi/waa.d.ts
@@ -171,3 +171,35 @@ declare enum OscillatorType {
   triangle,
   custom
 }
+
+interface AudioContextConstructor {
+    new(): AudioContext;
+}
+
+interface Window {
+    AudioContext: AudioContextConstructor;
+}
+
+interface AudioContext {
+    createMediaStreamSource(stream: MediaStream): MediaStreamAudioSourceNode;
+}
+
+interface MediaStreamAudioSourceNode extends AudioNode {
+    
+}
+
+interface AudioBuffer {
+    copyFromChannel(destination: Float32Array, channelNumber: number, startInChannel?: number): void;
+    
+    copyToChannel(source: Float32Array, channelNumber: number, startInChannel?: number): void;
+}
+
+interface AudioNode {
+    disconnect(destination: AudioNode): void;
+}
+
+interface AudioContext {
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+    close(): Promise<void>;
+}
diff --git a/webrtc/MediaStream-tests.ts b/webrtc/MediaStream-tests.ts
index 0d4e710b8..c309a281b 100644
--- a/webrtc/MediaStream-tests.ts
+++ b/webrtc/MediaStream-tests.ts
@@ -2,16 +2,17 @@
 var mediaStreamConstraints: MediaStreamConstraints = { audio: true, video: true };
 
 var mediaTrackConstraintSet: MediaTrackConstraintSet = {};
-var mediaTrackConstraintArray: MediaTrackConstraint[] = [];
-var mediaTrackConstraints: MediaTrackConstraints = { mandatory: mediaTrackConstraintSet, optional: mediaTrackConstraintArray }
+var mediaTrackConstraintArray: MediaTrackConstraintSet[] = [];
+var mediaTrackConstraints: MediaTrackConstraints = mediaTrackConstraintSet;
+var mediaTrackConstraints2: MediaTrackConstraints = { advanced: mediaTrackConstraintArray };
 
 navigator.getUserMedia(mediaStreamConstraints,
   stream => {
-    console.log('label:' + stream.label);
-    console.log('ended:' + stream.ended);
-    stream.onended = (event:Event) => console.log('Stream ended');
+    var track: MediaStreamTrack = stream.getTracks()[0];
+    console.log('label:' + track.label);
+    console.log('ended:' + track.readyState);
+    track.onended = (event:Event) => console.log('Track ended');
     var objectUrl = URL.createObjectURL(stream);
-    var wkObjectUrl = webkitURL.createObjectURL(stream);
   },
   error => {
     console.log('Error message: ' + error.message);
@@ -20,12 +21,11 @@ navigator.getUserMedia(mediaStreamConstraints,
 
 navigator.webkitGetUserMedia(mediaStreamConstraints,
   stream => {
-    console.log('label:' + stream.label);
-    console.log('ended:' + stream.ended);
-    stream.onended = (event:Event) => console.log('Stream ended');
-    stream.addEventListener("ended", (event:Event) => console.log('Stream ended'));
+    var track: MediaStreamTrack = stream.getTracks()[0];
+    console.log('label:' + track.label);
+    console.log('ended:' + track.readyState);
+    track.onended = (event:Event) => console.log('Track ended');
     var objectUrl = URL.createObjectURL(stream);
-    var wkObjectUrl = webkitURL.createObjectURL(stream);
   },
   error => {
     console.log('Error message: ' + error.message);
@@ -35,12 +35,11 @@ navigator.webkitGetUserMedia(mediaStreamConstraints,
 
 navigator.mozGetUserMedia(mediaStreamConstraints,
   stream => {
-    console.log('label:' + stream.label);
-    console.log('ended:' + stream.ended);
-    stream.onended = (event:Event) => console.log('Stream ended');
-    stream.addEventListener("ended", (event:Event) => console.log('Stream ended'));
+    var track: MediaStreamTrack = stream.getTracks()[0];
+    console.log('label:' + track.label);
+    console.log('ended:' + track.readyState);
+    track.onended = (event:Event) => console.log('Track ended');
     var objectUrl = URL.createObjectURL(stream);
-    var wkObjectUrl = webkitURL.createObjectURL(stream);
   },
   error => {
     console.log('Error message: ' + error.message);
diff --git a/webrtc/MediaStream.d.ts b/webrtc/MediaStream.d.ts
index 54de34e38..f52551a14 100644
--- a/webrtc/MediaStream.d.ts
+++ b/webrtc/MediaStream.d.ts
@@ -4,162 +4,190 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 // Taken from http://dev.w3.org/2011/webrtc/editor/getusermedia.html
+// version: W3C Editor's Draft 29 June 2015
+
+/// <reference path="../es6-promise/es6-promise.d.ts" />
+
+interface ConstrainBooleanParameters {
+    exact: boolean;
+    ideal: boolean;
+}
+
+interface NumberRange {
+    max: number;
+    min: number;
+}
+
+interface ConstrainNumberRange extends NumberRange {
+    exact: number;
+    ideal: number;
+}
+
+interface ConstrainStringParameters {
+    exact: string | string[];
+    ideal: string | string[];
+}
 
 interface MediaStreamConstraints {
-  audio: any;
-  video: any;
+    video?: boolean | MediaTrackConstraints;
+    audio?: boolean | MediaTrackConstraints;
 }
-declare var MediaStreamConstraints: {
-  prototype: MediaStreamConstraints;
-  new (): MediaStreamConstraints;
-};
 
-interface MediaTrackConstraints {
-  mandatory: MediaTrackConstraintSet;
-  optional: MediaTrackConstraint[];
+declare module W3C {
+    type LongRange = NumberRange;
+    type DoubleRange = NumberRange;
+    type ConstrainBoolean = boolean | ConstrainBooleanParameters;
+    type ConstrainNumber = number | ConstrainNumberRange;
+    type ConstrainLong = ConstrainNumber;
+    type ConstrainDouble = ConstrainNumber;
+    type ConstrainString = string | string[] | ConstrainStringParameters;
+}
+
+interface MediaTrackConstraints extends MediaTrackConstraintSet {
+    advanced?: MediaTrackConstraintSet[];
 }
-declare var MediaTrackConstraints: {
-  prototype: MediaTrackConstraints;
-  new (): MediaTrackConstraints;
-};
 
-// ks - Not defined in the source doc.
 interface MediaTrackConstraintSet {
+    width?: W3C.ConstrainLong;
+    height?: W3C.ConstrainLong;
+    aspectRatio?: W3C.ConstrainDouble;
+    frameRate?: W3C.ConstrainDouble;
+    facingMode?: W3C.ConstrainString;
+    volume?: W3C.ConstrainDouble;
+    sampleRate?: W3C.ConstrainLong;
+    sampleSize?: W3C.ConstrainLong;
+    echoCancellation?: W3C.ConstrainBoolean;
+    latency?: W3C.ConstrainDouble;
+    deviceId?: W3C.ConstrainString;
+    groupId?: W3C.ConstrainString;
 }
-declare var MediaTrackConstraintSet: {
-  prototype: MediaTrackConstraintSet;
-  new (): MediaTrackConstraintSet;
-};
 
-// ks - Not defined in the source doc.
-interface MediaTrackConstraint {
+interface MediaTrackSupportedConstraints {
+    width: boolean;
+    height: boolean;
+    aspectRatio: boolean;
+    frameRate: boolean;
+    facingMode: boolean;
+    volume: boolean;
+    sampleRate: boolean;
+    sampleSize: boolean;
+    echoCancellation: boolean;
+    latency: boolean;
+    deviceId: boolean;
+    groupId: boolean;
+}
+
+interface MediaStream extends EventTarget {
+    id: string;
+    active: boolean;
+    
+    onactive: EventListener;
+    oninactive: EventListener;
+    onaddtrack: (event: MediaStreamTrackEvent) => any;
+    onremovetrack: (event: MediaStreamTrackEvent) => any;
+    
+    clone(): MediaStream;
+    stop(): void;
+    
+    getAudioTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    getTracks(): MediaStreamTrack[];
+    
+    getTrackById(trackId: string): MediaStreamTrack;
+    
+    addTrack(track: MediaStreamTrack): void;
+    removeTrack(track: MediaStreamTrack): void;
+}
+
+interface MediaStreamTrackEvent extends Event {
+    track: MediaStreamTrack;
+}
+
+declare enum MediaStreamTrackState {
+	"live",
+    "ended"
+}
+
+interface MediaStreamTrack extends EventTarget {
+    id: string;
+    kind: string;
+    label: string;
+    enabled: boolean;
+    muted: boolean;
+    remote: boolean;
+    readyState: MediaStreamTrackState;
+    
+    onmute: EventListener;
+    onunmute: EventListener;
+    onended: EventListener;
+    onoverconstrained: EventListener;
+    
+    clone(): MediaStreamTrack;
+    
+    stop(): void;
+    
+    getCapabilities(): MediaTrackCapabilities;
+    getConstraints(): MediaTrackConstraints;
+    getSettings(): MediaTrackSettings;
+    applyConstraints(constraints: MediaTrackConstraints): Promise<void>;
+}
+
+interface MediaTrackCapabilities {
+    width: number | W3C.LongRange;
+    height: number | W3C.LongRange;
+    aspectRatio: number | W3C.DoubleRange;
+    frameRate: number | W3C.DoubleRange;
+    facingMode: string;
+    volume: number | W3C.DoubleRange;
+    sampleRate: number | W3C.LongRange;
+    sampleSize: number | W3C.LongRange;
+    echoCancellation: boolean[];
+    latency: number | W3C.DoubleRange;
+    deviceId: string;
+    groupId: string;
+}
+
+interface MediaTrackSettings {
+    width: number;
+    height: number;
+    aspectRatio: number;
+    frameRate: number;
+    facingMode: string;
+    volume: number;
+    sampleRate: number;
+    sampleSize: number;
+    echoCancellation: boolean;
+    latency: number;
+    deviceId: string;
+    groupId: string;
+}
+
+interface MediaStreamError {
+    name: string;
+    message: string;
+    constraintName: string;
+}
+
+interface NavigatorGetUserMedia {
+    (constraints: MediaStreamConstraints,
+     successCallback: (stream: MediaStream) => void,
+     errorCallback: (error: MediaStreamError) => void): void;
 }
-declare var MediaTrackConstraint: {
-  prototype: MediaTrackConstraint;
-  new (): MediaTrackConstraints;
-};
 
 interface Navigator {
-  getUserMedia(constraints: MediaStreamConstraints,
-               successCallback: (stream: any) => void,
-               errorCallback: (error: Error) => void) : void;
-  webkitGetUserMedia(constraints: MediaStreamConstraints,
-                     successCallback: (stream: any) => void,
-                     errorCallback: (error: Error) => void): void;
-  mozGetUserMedia(constraints: MediaStreamConstraints,
-                  successCallback: (stream: any) => void,
-                  errorCallback: (error: Error) => void): void;
+    getUserMedia: NavigatorGetUserMedia;
+    
+    webkitGetUserMedia: NavigatorGetUserMedia;
+    
+    mozGetUserMedia: NavigatorGetUserMedia;
+    
+    msGetUserMedia: NavigatorGetUserMedia;
+    
+    mediaDevices: MediaDevices;
 }
 
-interface EventHandler { (event: Event): void; }
-
-interface NavigatorUserMediaSuccessCallback {
-  (stream: LocalMediaStream): void;
+interface MediaDevices {
+    getSupportedConstraints(): MediaTrackSupportedConstraints;
+    
+    getUserMedia(constraints: MediaStreamConstraints): Promise<MediaStream>;
 }
-
-interface NavigatorUserMediaError {
-  PERMISSION_DENIED: number; // = 1;
-  code: number;
-}
-declare var NavigatorUserMediaError: {
-  prototype: NavigatorUserMediaError;
-  new (): NavigatorUserMediaError;
-  PERMISSION_DENIED: number; // = 1;
-};
-
-interface NavigatorUserMediaErrorCallback {
-  (error: NavigatorUserMediaError): void;
-}
-
-interface MediaStreamTrackList {
-  length: number;
-  item: MediaStreamTrack;
-  add(track: MediaStreamTrack): void;
-  remove(track: MediaStreamTrack): void;
-  onaddtrack: (event: Event) => void;
-  onremovetrack: (event: Event) => void;
-}
-declare var MediaStreamTrackList: {
-  prototype: MediaStreamTrackList;
-  new (): MediaStreamTrackList;
-};
-declare var webkitMediaStreamTrackList: {
-  prototype: MediaStreamTrackList;
-  new (): MediaStreamTrackList;
-};
-
-interface MediaStream extends EventTarget{
-  label: string;
-  id: string;
-  getAudioTracks(): MediaStreamTrackList;
-  getVideoTracks(): MediaStreamTrackList;
-  ended: boolean;
-  onended: (event: Event) => void;
-}
-declare var MediaStream: {
-  prototype: MediaStream;
-  new (): MediaStream;
-  new (trackContainers: MediaStream[]): MediaStream;
-  new (trackContainers: MediaStreamTrackList[]): MediaStream;
-  new (trackContainers: MediaStreamTrack[]): MediaStream;
-};
-declare var webkitMediaStream: {
-  prototype: MediaStream;
-  new (): MediaStream;
-  new (trackContainers: MediaStream[]): MediaStream;
-  new (trackContainers: MediaStreamTrackList[]): MediaStream;
-  new (trackContainers: MediaStreamTrack[]): MediaStream;
-};
-
-// an - not defined in source doc.
-interface SourceInfo {
-  label: string;
-  id: string;
-  kind: string;
-  facing: string;
-}
-declare var SourceInfo: {
-  prototype: SourceInfo;
-};
-
-interface LocalMediaStream extends MediaStream {
-  stop(): void;
-}
-
-interface MediaStreamTrack extends EventTarget{
-  kind: string;
-  label: string;
-  enabled: boolean;
-  LIVE: number; // = 0;
-  MUTED: number; // = 1;
-  ENDED: number; // = 2;
-  readyState: number;
-  onmute: (event: Event) => void;
-  onunmute: (event: Event) => void;
-  onended: (event: Event) => void;
-}
-declare var MediaStreamTrack: {
-  prototype: MediaStreamTrack;
-  new (): MediaStreamTrack;
-  LIVE: number; // = 0;
-  MUTED: number; // = 1;
-  ENDED: number; // = 2;
-  getSources: (callback: (sources: SourceInfo[]) => void) => void;
-};
-
-interface streamURL extends URL {
-  createObjectURL(stream: MediaStream): string;
-}
-//declare var URL: {
-//  prototype: MediaStreamTrack;
-//  new (): URL;
-//  createObjectURL(stream: MediaStream): string;
-//}
-
-interface WebkitURL extends streamURL {
-}
-declare var webkitURL: {
-  prototype: WebkitURL;
-  new (): streamURL;
-  createObjectURL(stream: MediaStream): string;
-};