Add a limitBitrateByPortalMinimum setting to prevent limiting too much

Author: robertbryer

index.d.ts

@@ -1839,6 +1839,7 @@ export class MediaPlayerSettingClass {
         abr?: {
             limitBitrateByPortal?: boolean;
             usePixelRatioInLimitBitrateByPortal?: boolean;
+            limitBitrateByPortalMinimum?: number,
             enableSupplementalPropertyAdaptationSetSwitching?: boolean,
             rules?: {
                 throughputRule?: {

src/core/Settings.js

@@ -746,6 +746,8 @@ import SwitchRequest from '../streaming/rules/SwitchRequest.js';
  * If true, the size of the video portal will limit the max chosen video resolution.
  * @property {boolean} [usePixelRatioInLimitBitrateByPortal=false]
  * Sets whether to take into account the device's pixel ratio when defining the portal dimensions.
+ * @property {number} [limitBitrateByPortalMinimum=0]
+ * Sets a minimum bitrate in kbps for limitBitrateByPortal. Representations at this bitrate or below it will not be limited by the portal size. Useful if the player can be resized.
  *
  * Useful on, for example, retina displays.
  * @property {module:Settings~AbrRules} [rules]
@@ -1324,6 +1326,7 @@ function Settings() {
             abr: {
                 limitBitrateByPortal: false,
                 usePixelRatioInLimitBitrateByPortal: false,
+                limitBitrateByPortalMinimum: 0,
                 enableSupplementalPropertyAdaptationSetSwitching: true,
                 rules: {
                     throughputRule: {

src/streaming/controllers/AbrController.js

@@ -400,12 +400,13 @@ function AbrController() {
             if (!settings.get().streaming.abr.limitBitrateByPortal) {
                 return voRepresentations;
             }
+            const minimum = (settings.get().streaming.abr.limitBitrateByPortalMinimum * 1000) || 0;
 
             const { elementWidth } = videoModel.getVideoElementSize();
 
             const filteredArray = voRepresentations.filter((voRepresentation) => {
-                return voRepresentation.mediaInfo.type !== Constants.VIDEO || voRepresentation.width <= elementWidth;
-            })
+                return voRepresentation.mediaInfo.type !== Constants.VIDEO || voRepresentation.width <= elementWidth || voRepresentation.bandwidth <= minimum;
+            });
 
             if (filteredArray.length > 0) {
                 return filteredArray

test/unit/test/streaming/streaming.controllers.AbrController.js

@@ -936,5 +936,61 @@ describe('AbrController', function () {
             let possibleVoRepresentations = abrCtrl.getPossibleVoRepresentationsFilteredBySettings(mediaInfo);
             expect(possibleVoRepresentations.length).to.be.equal(2);
         });
-    })
+
+        it('should allow representations with a bandwidth below limitBitrateByPortalMinimum', function () {
+            videoModelMock.getVideoElementSize = () => {
+                return { elementWidth: 200 }
+            };
+            const s = {
+                streaming: {
+                    abr: {
+                        limitBitrateByPortal: true,
+                        limitBitrateByPortalMinimum: 2100
+                    }
+                }
+            };
+            settings.update(s);
+
+            const mediaInfo = streamProcessor.getMediaInfo();
+            const bitrateList = mediaInfo.bitrateList;
+
+            adapterMock.getVoRepresentations = () => {
+                return [
+                    {
+                        bitrateInKbit: bitrateList[0].bandwidth / 1000,
+                        bandwidth: 1000000,
+                        mediaInfo,
+                        id: 1,
+                        width: 640
+                    },
+                    {
+                        bitrateInKbit: bitrateList[1].bandwidth / 1000,
+                        bandwidth: 2000000,
+                        mediaInfo,
+                        id: 2,
+                        width: 720
+                    },
+                    {
+                        bitrateInKbit: bitrateList[2].bandwidth / 1000,
+                        bandwidth: 3000000,
+                        mediaInfo,
+                        id: 3,
+                        width: 1920
+                    }
+                ]
+            }
+
+            adapterMock.areMediaInfosEqual = () => {
+                return true
+            }
+
+            mediaInfo.streamInfo = streamProcessor.getStreamInfo();
+            mediaInfo.type = Constants.VIDEO;
+
+            let possibleVoRepresentations = abrCtrl.getPossibleVoRepresentationsFilteredBySettings(mediaInfo);
+            expect(possibleVoRepresentations.length).to.be.equal(2);
+            expect(possibleVoRepresentations[0].id).to.be.equal(1);
+            expect(possibleVoRepresentations[1].id).to.be.equal(2);
+        });
+    });
 });