Misc fixes

src/app.ts

@@ -3,20 +3,6 @@ import './components/maincontroller';
 import './css/glyphicons.css';
 import './css/jellyfin.css';
 
-const senders = cast.framework.CastReceiverContext.getInstance().getSenders();
-const id =
-    senders.length !== 0 && senders[0].id
-        ? senders[0].id
-        : new Date().getTime();
-
-window.deviceInfo = {
-    deviceId: id,
-    deviceName: 'Google Cast',
-    versionNumber: RECEIVERVERSION
-};
-
 window.mediaElement = document.getElementById('video-player');
 
-window.playlist = [];
-window.currentPlaylistIndex = -1;
 window.repeatMode = RepeatMode.RepeatNone;

src/components/codecSupportHelper.ts

@@ -102,22 +102,28 @@ export function getMaxBitrateSupport(): number {
 /**
  * Get the max supported video width the active Cast device supports.
  *
- * @param deviceId - Cast device id.
  * @returns Max supported width.
  */
-export function getMaxWidthSupport(deviceId: number): number {
-    switch (deviceId) {
-        case deviceIds.ULTRA:
-        case deviceIds.CCGTV:
-            return 3840;
-        case deviceIds.GEN1AND2:
-        case deviceIds.GEN3:
-            return 1920;
-        case deviceIds.NESTHUBANDMAX:
-            return 1280;
-    }
-
-    return 0;
+export function getMaxWidthSupport(): number {
+    // with HLS, it will produce a manifest error if we
+    // send any stream larger than the screen size...
+    return window.innerWidth;
+
+    // mkv playback can use the device limitations.
+    // The devices are capable of decoding and downscaling,
+    // they just refuse to do it with HLS. This increases
+    // the rate of direct playback.
+    //switch (deviceId) {
+    //    case deviceIds.ULTRA:
+    //    case deviceIds.CCGTV:
+    //        return 3840;
+    //    case deviceIds.GEN1AND2:
+    //    case deviceIds.GEN3:
+    //        return 1920;
+    //    case deviceIds.NESTHUBANDMAX:
+    //        return 1280;
+    //}
+    //return 0;
 }
 
 /**

src/components/commandHandler.ts

@@ -19,13 +19,12 @@ import {
 
 import { reportPlaybackProgress } from './jellyfinActions';
 
-import { playbackManager } from './playbackManager';
+import { PlaybackManager } from './playbackManager';
 
 import { DocumentManager } from './documentManager';
 
 export abstract class CommandHandler {
     private static playerManager: framework.PlayerManager;
-    private static playbackManager: playbackManager;
     private static supportedCommands: SupportedCommands = {
         DisplayContent: CommandHandler.displayContentHandler,
         Identify: CommandHandler.IdentifyHandler,
@@ -52,12 +51,8 @@ export abstract class CommandHandler {
         VolumeUp: CommandHandler.VolumeUpHandler
     };
 
-    static configure(
-        playerManager: framework.PlayerManager,
-        playbackManager: playbackManager
-    ): void {
+    static configure(playerManager: framework.PlayerManager): void {
         this.playerManager = playerManager;
-        this.playbackManager = playbackManager;
     }
 
     static playNextHandler(data: DataMessage): void {
@@ -89,23 +84,20 @@ export abstract class CommandHandler {
     }
 
     static displayContentHandler(data: DataMessage): void {
-        if (!this.playbackManager.isPlaying()) {
+        if (!PlaybackManager.isPlaying()) {
             DocumentManager.showItemId((<DisplayRequest>data.options).ItemId);
         }
     }
 
     static nextTrackHandler(): void {
-        if (
-            window.playlist &&
-            window.currentPlaylistIndex < window.playlist.length - 1
-        ) {
-            this.playbackManager.playNextItem({}, true);
+        if (PlaybackManager.hasNextItem()) {
+            PlaybackManager.playNextItem({}, true);
         }
     }
 
     static previousTrackHandler(): void {
-        if (window.playlist && window.currentPlaylistIndex > 0) {
-            this.playbackManager.playPreviousItem({});
+        if (PlaybackManager.hasPrevItem()) {
+            PlaybackManager.playPreviousItem({});
         }
     }
 
@@ -138,7 +130,8 @@ export abstract class CommandHandler {
     }
 
     static IdentifyHandler(): void {
-        if (!this.playbackManager.isPlaying()) {
+        if (!PlaybackManager.isPlaying()) {
+            DocumentManager.setAppStatus('waiting');
             DocumentManager.startBackdropInterval();
         } else {
             // When a client connects send back the initial device state (volume etc) via a playbackstop message

src/components/deviceprofileBuilder.ts

@@ -195,7 +195,7 @@ function getCodecProfiles(): Array<CodecProfile> {
 
     CodecProfiles.push(aacConditions);
 
-    const maxWidth: number = getMaxWidthSupport(currentDeviceId);
+    const maxWidth: number = getMaxWidthSupport();
     const h26xLevel: number = getH26xLevelSupport(currentDeviceId);
     const h26xProfile: string = getH26xProfileSupport(currentDeviceId);
 

src/components/jellyfinActions.ts

@@ -1,7 +1,6 @@
 import {
     getSenderReportingData,
     resetPlaybackScope,
-    extend,
     broadcastToMessageBus
 } from '../helpers';
 
@@ -199,12 +198,22 @@ export function pingTranscoder(
  */
 export function load(
     $scope: GlobalScope,
-    customData: PlaybackProgressInfo,
+    customData: any,
     serverItem: BaseItemDto
 ): void {
     resetPlaybackScope($scope);
 
-    extend($scope, customData);
+    // These are set up in maincontroller.createMediaInformation
+    $scope.playSessionId = customData.playSessionId;
+    $scope.audioStreamIndex = customData.audioStreamIndex;
+    $scope.subtitleStreamIndex = customData.subtitleStreamIndex;
+    $scope.startPositionTicks = customData.startPositionTicks;
+    $scope.canSeek = customData.canSeek;
+    $scope.itemId = customData.itemId;
+    $scope.liveStreamId = customData.liveStreamId;
+    $scope.mediaSourceId = customData.mediaSourceId;
+    $scope.playMethod = customData.playMethod;
+    $scope.runtimeTicks = customData.runtimeTicks;
 
     $scope.item = serverItem;
 
@@ -230,7 +239,7 @@ export function play($scope: GlobalScope): void {
         DocumentManager.getAppStatus() == 'audio'
     ) {
         setTimeout(() => {
-            window.mediaManager.play();
+            window.playerManager.play();
 
             if ($scope.mediaType == 'Audio') {
                 DocumentManager.setAppStatus('audio');
@@ -241,15 +250,6 @@ export function play($scope: GlobalScope): void {
     }
 }
 
-/**
- * Don't actually stop, just show the idle view after 20ms
- */
-export function stop(): void {
-    setTimeout(() => {
-        DocumentManager.setAppStatus('waiting');
-    }, 20);
-}
-
 /**
  * @param item
  * @param maxBitrate
@@ -369,11 +369,14 @@ export async function getDownloadSpeed(byteSize: number): Promise<number> {
 
     const now = new Date().getTime();
 
-    await JellyfinApi.authAjax(path, {
+    const response = await JellyfinApi.authAjax(path, {
         timeout: 5000,
         type: 'GET'
     });
 
+    // Force javascript to download the whole response before calculating bitrate
+    await response.blob();
+
     const responseTimeSeconds = (new Date().getTime() - now) / 1000;
     const bytesPerSecond = byteSize / responseTimeSeconds;
     const bitrate = Math.round(bytesPerSecond * 8);
@@ -383,22 +386,29 @@ export async function getDownloadSpeed(byteSize: number): Promise<number> {
 
 /**
  * Function to detect the bitrate.
- * It first tries 1MB and if bitrate is above 1Mbit/s it tries again with 2.4MB.
+ * It starts at 500kB and doubles it every time it takes under 2s, for max 10MB.
+ * This should get an accurate bitrate relatively fast on any connection
  *
+ * @param numBytes - Number of bytes to start with, default 500k
  * @returns bitrate in bits/s
  */
-export async function detectBitrate(): Promise<number> {
-    // First try a small amount so that we don't hang up their mobile connection
+export async function detectBitrate(numBytes = 500000): Promise<number> {
+    // Jellyfin has a 10MB limit on the test size
+    const byteLimit = 10000000;
 
-    let bitrate = await getDownloadSpeed(1000000);
-
-    if (bitrate < 1000000) {
-        return Math.round(bitrate * 0.8);
+    if (numBytes > byteLimit) {
+        numBytes = byteLimit;
     }
 
-    bitrate = await getDownloadSpeed(2400000);
+    const bitrate = await getDownloadSpeed(numBytes);
 
-    return Math.round(bitrate * 0.8);
+    if (bitrate * (2 / 8.0) < numBytes || numBytes >= byteLimit) {
+        // took > 2s, or numBytes hit the limit
+        return Math.round(bitrate * 0.8);
+    } else {
+        // If that produced a fairly high speed, try again with a larger size to get a more accurate result
+        return await detectBitrate(numBytes * 2);
+    }
 }
 
 /**
@@ -409,7 +419,7 @@ export async function detectBitrate(): Promise<number> {
  */
 export function stopActiveEncodings($scope: GlobalScope): Promise<void> {
     const options = {
-        deviceId: window.deviceInfo.deviceId,
+        deviceId: JellyfinApi.deviceId,
         PlaySessionId: undefined
     };
 

src/components/jellyfinApi.ts

@@ -11,28 +11,55 @@ export abstract class JellyfinApi {
     // Address of server
     public static serverAddress: string | null = null;
 
+    // device name
+    public static deviceName = 'Google Cast';
+
+    // unique id
+    public static deviceId = '';
+
+    // version
+    public static versionNumber = RECEIVERVERSION;
+
     public static setServerInfo(
         userId: string,
         accessToken: string,
-        serverAddress: string
+        serverAddress: string,
+        receiverName: string
     ): void {
         console.debug(
-            `JellyfinApi.setServerInfo: user:${userId}, token:${accessToken}, server:${serverAddress}`
+            `JellyfinApi.setServerInfo: user:${userId}, token:${accessToken}, ` +
+                `server:${serverAddress}, name:${receiverName}`
         );
         this.userId = userId;
         this.accessToken = accessToken;
         this.serverAddress = serverAddress;
+
+        // remove special characters from the receiver name
+        receiverName = receiverName.replace(/[^\w\s]/gi, '');
+
+        if (receiverName) {
+            this.deviceName = receiverName;
+            // deviceId just needs to be unique-ish
+            this.deviceId = btoa(receiverName);
+        } else {
+            const senders =
+                cast.framework.CastReceiverContext.getInstance().getSenders();
+
+            this.deviceName = 'Google Cast';
+            this.deviceId =
+                senders.length !== 0 && senders[0].id
+                    ? senders[0].id
+                    : new Date().getTime().toString();
+        }
     }
 
     // create the necessary headers for authentication
     private static getSecurityHeaders(): Dictionary<string> {
         // TODO throw error if this fails
 
         let auth =
-            `Emby Client="Chromecast", ` +
-            `Device="${window.deviceInfo.deviceName}", ` +
-            `DeviceId="${window.deviceInfo.deviceId}", ` +
-            `Version="${window.deviceInfo.versionNumber}"`;
+            `Emby Client="Chromecast", Device="${this.deviceName}", ` +
+            `DeviceId="${this.deviceId}", Version="${this.versionNumber}"`;
 
         if (this.userId) {
             auth += `, UserId="${this.userId}"`;