Updating video send constriants doc

Author: pkestikar-msft

articles/communication-services/quickstarts/voice-video-calling/includes/video-constraints/video-constraints-javascript.md

@@ -11,22 +11,32 @@ ms.service: azure-communication-services
 ms.subservice: calling
 ---
 
-The Video Constraints API enables developers to control the video quality from within their video calls. In this quickstart guide, we'll illustrate how to use the API to set the constraints.
+You can set video constraints in your calls to control the video quality based on resolution or frameRate or bitrate in your video calls. In this quickstart guide, we'll illustrate how to set video constraints at the start of a call and how to use our `setConstraints` method on the call object to set video constraints dynamically during the call.
 
 
 [!INCLUDE [Public Preview](../../../../includes/public-preview-include-document.md)]
 
-## Using video constraints
-The video constraints setting is implemented on the `Call` interface. To use the Video Constraints, you can specify the constraints from within CallOptions when you make a call, accept a call, or join a call. You will also have to specify `localVideoStreams` in `videoOptions`. Do note that constraints don't work if you join a call with audio only option and turn on the camera later.
+> [!NOTE]
+> Currently, we only support setting video send constraints. You cannot set video constraints on incoming videos at this point of time.
+
+## Setting video constraints at the start of a call
+The video constraints setting is implemented on the `Call` interface. To use the Video Constraints, you can specify the constraints from within `CallOptions` when you make a call, accept a call, or join a call. You will also have to specify `localVideoStreams` in `videoOptions`. <br/>
+Do note that constraints don't work if you join a call with audio only option and turn on the camera later. In this case, you can set video constraints dynamically using the `setConstraints` method on the `Call` interface (guide below).
 
 ```javascript
 const callOptions = {
     videoOptions: {
         localVideoStreams: [...],
         constraints: {
             send: {
-                height: {
+                bitrate: {
+                    max: 575000
+                },
+                frameHeight: {
                     max: 240
+                },
+                frameRate: {
+                    max: 20
                 }
             }
         }
@@ -50,42 +60,89 @@ export declare interface VideoOptions {
     //video constraint when call starts
     constraints?: VideoConstraints;
 };
+
 export declare type VideoConstraints = {
     send?: VideoSendConstraints;
 };
-export declare type VideoSendConstraints = {
-    height?: MediaConstraintRange;
+
+export type VideoSendConstraints = {
+    /**
+     * Resolution constraint
+     */
+    frameHeight?: MediaConstraintRange;
+
+    /**
+     * FrameRate constraint
+     */
+    frameRate?: MediaConstraintRange;
+
+    /**
+     * Bitrate constriant
+     */
+    bitrate?: MediaConstraintRange;
 };
+
 export declare type MediaConstraintRange = {
     max?: number;
 };
 ```
 
-### Sender max video resolution constraint
+When setting video constraints, the SDK will choose the nearest value that falls within the constraint set (to prevent the values for resolution, frameRate and bitrate to not exceed the maximum constraint values set). Also, when the resolution constraint value is too small, the SDK will choose the smallest available resolution. In this case, the height of chosen resolution can be larger than the constraint value.
 
-With sender max video resolution constraint, you can limit the max video resolution of the sending stream. The value you have to provide for this constraint is `height`.
+> [!NOTE]
+> For all `bitrate`, `frameHeight` and `frameRate`, the constraint value is a `max` constraint, which means the actual value in the call can be the specified value or smaller.
+> There is no gurantee that the sent video resolution will remain at the specified resolution.
+
+The `frameHeight` in `VideoSendConstraints` has a different meaning when a mobile device is in portrait mode. In portrait mode, this value indicates the shorter side of the device. For example, specifying `frameHeight.max` value with 240 on a 1080(W) x 1920(H) device in portrait mode, the constraint height is on the 1080(W) side. When the same device is in landscape mode (1920(W) x 1080(H)), the constraint is on the 1080(H) side.
+
+If you use MediaStats API to track the sent video resolution, you may find out that the sent resolution can change during the call. It can go up and down, but should be equal or smaller than the constraint value you provide. This resolution change is an expected behavior. The browser also has some degradation rule to adjust sent resolution based on cpu or network conditions.
 
+## Setting video constraints during the call
+You can set video constraints during the call by using the `setConstraints` method on the `Call` object.
 ```javascript
-{
-    localVideoStreams: [...],
-    constraints: {
+// For eg, when you've started a call,
+const currentCall = this.callAgent.startCall(identitiesToCall, callOptions);
+
+// To set constraints during the call,
+await currentCall.setConstraints({
+    video: {
         send: {
-            height: {
-                max: 240
+            frameHeight: {
+                max: 360
+            },
+            frameRate: {
+                max: 15
             }
         }
     }
-}
-```
-When setting the maximum resolution video constraints, the SDK will choose the nearest resolution that falls within the constraint set (to prevent the resolution height doesn't exceed the maximum constraint value allowed). Also, when the resolution constraint value is too small, the SDK will choose the smallest available resolution. In this case, the height of chosen resolution can be larger than the constraint value.
+});
 
-> [!NOTE]
-> The resolution constraint is a `max` constraint, which means the possible resolutions can be the specified resolution or smaller.
-> There is no gurantee that the sent video resolution will remain at the specified resolution.
+// To set only a particular constraint (the others will stay as what they were set before, if they were set)
+await currentCall.setConstraints({
+    video: {
+        send: {
+            bitrate: {
+                max: 400000
+            }
+        }
+    }
+});
 
-The `height` in `VideoSendConstraints` has a different meaning when a mobile device is in portrait mode. In portrait mode, this value indicates the shorter side of the device. For example, specifying `constraints.send.height.max` value with 240 on a 1080(W) x 1920(H) device in portrait mode, the constraint height is on the 1080(W) side. When the same device is in landscape mode (1920(W) x 1080(H)), the constraint is on the 1080(H) side.
+// To unset any constraint,
+await currentCall.setConstraints({
+    video: {
+        send: {
+            frameHeight: {
+                max: 0
+            }
+        }
+    }
+});
+```
+> [!NOTE]
+> Setting constraint value as `0` will unset any previously set constraints. You can use this way to reset or remove constraints.
 
-If you use MediaStats API to track the sent video resolution, you may find out that the sent resolution can change during the call. It can go up and down, but should be equal or smaller than the constraint value you provide. This resolution change is an expected behavior. The browser also has some degradation rule to adjust sent resolution based on cpu or network conditions.
+<br/>
 
 ### Media stats
 To evaluate and compare the video quality after applying the video constraints, you can access [MediaStats API](../../../../concepts/voice-video-calling/media-quality-sdk.md) to get video resolution and bitrate information of the sending stream. The media stats also include other granular stats related to the streams, such as jitter, packet loss, round trip time, etc.