Support setting and getting of playback bitrate (#391)

* initial commit

* rename method signature and params

* updated tests

Author: markhouldridge

src/bigscreenplayer.js

@@ -471,6 +471,24 @@ function BigscreenPlayer() {
      */
     getPlaybackRate: () => playerComponent && playerComponent.getPlaybackRate(),
 
+    /**
+     * Set constrained bitrate given a min/max range and mediakind.
+     */
+    setBitrateConstraint: (mediaKind, minBitrateKbps, maxBitrateKbps) => {
+      if (playerComponent) {
+        playerComponent.setBitrateConstraint(mediaKind, minBitrateKbps, maxBitrateKbps)
+      }
+    },
+
+    /**
+     * Returns current playback bitrate for media kind.
+     */
+    getPlaybackBitrate: (mediaKind) => {
+      if (playerComponent) {
+        return playerComponent.getPlaybackBitrate(mediaKind)
+      }
+    },
+
     /**
      * Returns the media asset's current time in seconds.
      * @function

src/bigscreenplayer.test.js

@@ -116,6 +116,8 @@ describe("Bigscreen Player", () => {
       isAudioDescribedAvailable: jest.fn(),
       isAudioDescribedEnabled: jest.fn(),
       setAudioDescribed: jest.fn(),
+      setBitrateConstraint: jest.fn(),
+      getPlaybackBitrate: jest.fn(),
     }
 
     jest.spyOn(PlayerComponent, "getLiveSupport").mockReturnValue(LiveSupport.SEEKABLE)
@@ -1669,4 +1671,35 @@ describe("Bigscreen Player", () => {
       expect(DebugTool.getDebugLogs).toHaveBeenCalledTimes(1)
     })
   })
+
+  describe("Set and get playback bitrate", () => {
+    const mediaKind = "video"
+    const minBitrateKbps = 100
+    const maxBitrateKbps = 200
+
+    it("should set bitrate on the strategy", async () => {
+      await asyncInitialiseBigscreenPlayer(createPlaybackElement(), bigscreenPlayerData)
+      bigscreenPlayer.setBitrateConstraint(mediaKind, minBitrateKbps, maxBitrateKbps)
+
+      expect(mockPlayerComponentInstance.setBitrateConstraint).toHaveBeenLastCalledWith(
+        mediaKind,
+        minBitrateKbps,
+        maxBitrateKbps
+      )
+    })
+
+    it("should not set the bitrate if playerComponent is not initialised", async () => {
+      bigscreenPlayer.setBitrateConstraint(mediaKind, minBitrateKbps, maxBitrateKbps)
+
+      expect(mockPlayerComponentInstance.setBitrateConstraint).not.toHaveBeenCalled()
+    })
+
+    it("should return the bitrate given a media kind", async () => {
+      await asyncInitialiseBigscreenPlayer(createPlaybackElement(), bigscreenPlayerData)
+      mockPlayerComponentInstance.getPlaybackBitrate.mockReturnValue(100)
+      bigscreenPlayer.getPlaybackBitrate(mediaKind)
+
+      expect(mockPlayerComponentInstance.getPlaybackBitrate()).toBe(100)
+    })
+  })
 })

src/playbackstrategy/msestrategy.js

@@ -415,7 +415,7 @@ function MSEStrategy(
 
     const bitrateInfoList = mediaPlayer.getBitrateInfoListFor(mediaKind)
 
-    return bitrateInfoList[index].bitrate ?? 0
+    return bitrateInfoList?.[index].bitrate ?? 0
   }
 
   function onQualityChangeRequested(event) {
@@ -995,6 +995,26 @@ function MSEStrategy(
     }
   }
 
+  /*
+   * Set constrained audio or video bitrate
+   */
+  function setBitrateConstraint(mediaKind, minBitrateKbps, maxBitrateKbps) {
+    mediaPlayer.updateSettings({
+      streaming: {
+        abr: {
+          minBitrate: {
+            audio: mediaKind === MediaKinds.AUDIO ? minBitratKbps : -1,
+            video: mediaKind === MediaKinds.VIDEO ? minBitrateKbps : -1,
+          },
+          maxBitrate: {
+            audio: mediaKind === MediaKinds.AUDIO ? maxBitrateKbps : -1,
+            video: mediaKind === MediaKinds.VIDEO ? maxBitrateKbps : -1,
+          },
+        },
+      },
+    })
+  }
+
   return {
     transitions: {
       canBePaused: () => true,
@@ -1039,6 +1059,8 @@ function MSEStrategy(
     setCurrentTime,
     setPlaybackRate: (rate) => mediaPlayer.setPlaybackRate(rate),
     getPlaybackRate: () => mediaPlayer.getPlaybackRate(),
+    setBitrateConstraint,
+    getPlaybackBitrate: (mediaKind) => currentPlaybackBitrateInKbps(mediaKind),
   }
 }
 

src/playbackstrategy/msestrategy.test.js

@@ -89,6 +89,8 @@ function createMockDashInstance() {
     setInitialMediaSettingsFor: jest.fn(),
     setAutoPlay: jest.fn(),
     setProtectionData: jest.fn(),
+    setBitrateConstraint: jest.fn(),
+    getPlaybackBitrate: jest.fn(),
   }
 }
 
@@ -1915,4 +1917,23 @@ describe("Media Source Extensions Playback Strategy", () => {
       expect(mockDashInstance.attachTTMLRenderingDiv).toHaveBeenCalledWith(subtitlesElement)
     })
   })
+
+  describe("Playback bitrate", () => {
+    it("setBitrateConstraint should call media player updateSettings", () => {
+      const mseStrategy = MSEStrategy(mockMediaSources, MediaKinds.VIDEO, playbackElement)
+      mseStrategy.load(null, 0)
+      mseStrategy.setBitrateConstraint("video", 100, 200)
+
+      expect(mockDashInstance.updateSettings).toHaveBeenCalled()
+    })
+
+    it("getPlaybackBitrate returns the current playback bitrate in kbps", () => {
+      const mseStrategy = MSEStrategy(mockMediaSources, MediaKinds.VIDEO, playbackElement)
+      mseStrategy.load(null, 0)
+      mockDashInstance.getBitrateInfoListFor.mockReturnValue([{ bitrate: 100000 }])
+      const bitrate = mseStrategy.getPlaybackBitrate("video")
+
+      expect(bitrate).toBe(100)
+    })
+  })
 })

src/playercomponent.js

@@ -447,6 +447,14 @@ function PlayerComponent(
     fatalError = undefined
   }
 
+  function setBitrateConstraint(mediaKind, minBitrateKbps, maxBitrateKbps) {
+    playbackStrategy?.setBitrateConstraint(mediaKind, minBitrateKbps, maxBitrateKbps)
+  }
+
+  function getPlaybackBitrate(mediaKind) {
+    return playbackStrategy?.getPlaybackBitrate(mediaKind)
+  }
+
   return {
     play,
     pause,
@@ -467,6 +475,8 @@ function PlayerComponent(
     isAudioDescribedEnabled,
     setAudioDescribed,
     setSubtitles,
+    setBitrateConstraint,
+    getPlaybackBitrate,
   }
 }
 

src/playercomponent.test.js

@@ -56,6 +56,8 @@ function createMockPlaybackStrategy(liveSupport = LiveSupport.SEEKABLE, extraFie
     isAudioDescribedEnabled: jest.fn(),
     setAudioDescribedOn: jest.fn(),
     setAudioDescribedOff: jest.fn(),
+    setBitrateConstraint: jest.fn(),
+    getPlaybackBitrate: jest.fn(),
     ...extraFields,
   }
 }
@@ -1611,4 +1613,35 @@ describe("Player Component", () => {
       expect(mockStrategy.tearDown).toHaveBeenCalledTimes(1)
     })
   })
+
+  describe("Set and get playback bitrate", () => {
+    it("setBitrateConstraint calls the the strategy to update settings", async () => {
+      const playerComponent = new PlayerComponent(
+        createPlaybackElement(),
+        bigscreenPlayerData,
+        mockMediaSources,
+        jest.fn(),
+        jest.fn()
+      )
+      await jest.runOnlyPendingTimersAsync()
+      playerComponent.setBitrateConstraint("video", 100, 200)
+
+      expect(mockStrategy.setBitrateConstraint).toHaveBeenCalledWith("video", 100, 200)
+    })
+
+    it("getPlaybackBitrate returns the strategy playback bitrate", async () => {
+      mockStrategy.getPlaybackBitrate.mockReturnValueOnce(100)
+      const playerComponent = new PlayerComponent(
+        createPlaybackElement(),
+        bigscreenPlayerData,
+        mockMediaSources,
+        jest.fn(),
+        jest.fn()
+      )
+      await jest.runOnlyPendingTimersAsync()
+
+      expect(playerComponent.getPlaybackBitrate()).toBe(100)
+      expect(mockStrategy.getPlaybackBitrate).toHaveBeenCalledTimes(1)
+    })
+  })
 })