feat: Improved movie playback and listing stream options

backend/plugins/jellyfin.plugin/src/index.ts

@@ -13,7 +13,14 @@ import {
   Subtitles,
   UserContext,
   VideoStream,
+  VideoStreamCandidate,
 } from 'plugins/plugin-types';
+import {
+  bitrateQualities,
+  formatSize,
+  formatTicksToTime,
+  getClosestBitrate,
+} from './utils';
 
 interface JellyfinSettings extends PluginSettings {
   apiKey: string;
@@ -27,68 +34,14 @@ interface JellyfinUserContext extends UserContext {
 
 const JELLYFIN_DEVICE_ID = 'Reiverr Client';
 
-const bitrateQualities = [
-  {
-    label: '4K - 120 Mbps',
-    bitrate: 120000000,
-    codec: undefined,
-  },
-  {
-    label: '4K - 80 Mbps',
-    bitrate: 80000000,
-    codec: undefined,
-  },
-  {
-    label: '1080p - 40 Mbps',
-    bitrate: 40000000,
-    codec: undefined,
-  },
-  {
-    label: '1080p - 10 Mbps',
-    bitrate: 10000000,
-    codec: undefined,
-  },
-  {
-    label: '720p - 8 Mbps',
-    bitrate: 8000000,
-    codec: undefined,
-  },
-  {
-    label: '720p - 4 Mbps',
-    bitrate: 4000000,
-    codec: undefined,
-  },
-  {
-    label: '480p - 3 Mbps',
-    bitrate: 3000000,
-    codec: undefined,
-  },
-  {
-    label: '480p - 720 Kbps',
-    bitrate: 720000,
-    codec: undefined,
-  },
-  {
-    label: '360p - 420 Kbps',
-    bitrate: 420000,
-    codec: undefined,
-  },
-];
-
-function getClosestBitrate(qualities, bitrate) {
-  return qualities.reduce(
-    (prev, curr) =>
-      Math.abs(curr.bitrate - bitrate) < Math.abs(prev.bitrate - bitrate)
-        ? curr
-        : prev,
-    qualities[0],
-  );
-}
-
 @Injectable()
 export default class JellyfinPlugin implements SourcePlugin {
   name: string = 'jellyfin';
 
+  private getProxyUrl(tmdbId: string) {
+    return `/api/movies/${tmdbId}/sources/${this.name}/stream/proxy`;
+  }
+
   validateSettings: (settings: JellyfinSettings) => Promise<{
     isValid: boolean;
     errors: Record<string, string>;
@@ -213,8 +166,25 @@ export default class JellyfinPlugin implements SourcePlugin {
       .then((res) => res.data.Items ?? []);
   }
 
+  async getMovieStreams(
+    tmdbId: string,
+    userContext: JellyfinUserContext,
+    config: PlaybackConfig = {
+      audioStreamIndex: undefined,
+      bitrate: undefined,
+      progress: undefined,
+      defaultLanguage: undefined,
+      deviceProfile: undefined,
+    },
+  ): Promise<VideoStreamCandidate[]> {
+    return this.getMovieStream(tmdbId, '', userContext, config).then(
+      (stream) => [stream],
+    );
+  }
+
   async getMovieStream(
     tmdbId: string,
+    key: string,
     userContext: JellyfinUserContext,
     config: PlaybackConfig = {
       audioStreamIndex: undefined,
@@ -226,7 +196,7 @@ export default class JellyfinPlugin implements SourcePlugin {
   ): Promise<VideoStream> {
     const context = new PluginContext(userContext.settings, userContext.token);
     const items = await this.getLibraryItems(context);
-    const proxyUrl = `/api/movies/${tmdbId}/sources/${this.name}/stream`;
+    const proxyUrl = this.getProxyUrl(tmdbId);
 
     const movie = items.find((item) => item.ProviderIds?.Tmdb === tmdbId);
 
@@ -288,22 +258,20 @@ export default class JellyfinPlugin implements SourcePlugin {
         index: s.Index,
       })) ?? [];
 
-    const qualities = [
+    const qualities: VideoStream['qualities'] = [
       ...bitrateQualities,
       {
         bitrate: mediasSource.Bitrate,
         label: 'Original',
         codec: undefined,
+        original: true,
       },
     ].map((q, i) => ({
       ...q,
       index: i,
     }));
 
-    const bitrate = Math.min(
-      maxStreamingBitrate,
-      movie.MediaSources[0].Bitrate,
-    );
+    const bitrate = Math.min(maxStreamingBitrate, mediasSource.Bitrate);
 
     const subtitles: Subtitles[] = mediasSource.MediaStreams.filter(
       (s) => s.Type === 'Subtitle' && s.DeliveryUrl,
@@ -315,6 +283,32 @@ export default class JellyfinPlugin implements SourcePlugin {
     }));
 
     return {
+      key: '',
+      title: movie.Name,
+      properties: [
+        {
+          label: 'Video',
+          value: mediasSource.Bitrate || 0,
+          formatted:
+            mediasSource.MediaStreams.find((s) => s.Type === 'Video')
+              ?.DisplayTitle || 'Unknown',
+        },
+        {
+          label: 'Size',
+          value: mediasSource.Size,
+          formatted: formatSize(mediasSource.Size),
+        },
+        {
+          label: 'Filename',
+          value: mediasSource.Name,
+          formatted: undefined,
+        },
+        {
+          label: 'Runtime',
+          value: mediasSource.RunTimeTicks,
+          formatted: formatTicksToTime(mediasSource.RunTimeTicks),
+        },
+      ],
       audioStreamIndex:
         config.audioStreamIndex ??
         mediasSource?.DefaultAudioStreamIndex ??
@@ -322,7 +316,7 @@ export default class JellyfinPlugin implements SourcePlugin {
       audioStreams,
       progress: config.progress ?? 0,
       qualities,
-      quality: getClosestBitrate(qualities, bitrate).index,
+      qualityIndex: getClosestBitrate(qualities, bitrate).index,
       subtitles,
       uri: playbackUri,
       directPlay:

backend/plugins/jellyfin.plugin/src/utils.ts

@@ -0,0 +1,91 @@
+export function formatSize(size: number) {
+  const gbs = size / 1024 / 1024 / 1024;
+  const mbs = size / 1024 / 1024;
+
+  if (gbs >= 1) {
+    return `${gbs.toFixed(2)} GB`;
+  } else {
+    return `${mbs.toFixed(2)} MB`;
+  }
+}
+
+export const bitrateQualities = [
+  {
+    label: '4K - 120 Mbps',
+    bitrate: 120000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '4K - 80 Mbps',
+    bitrate: 80000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '1080p - 40 Mbps',
+    bitrate: 40000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '1080p - 10 Mbps',
+    bitrate: 10000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '720p - 8 Mbps',
+    bitrate: 8000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '720p - 4 Mbps',
+    bitrate: 4000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '480p - 3 Mbps',
+    bitrate: 3000000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '480p - 720 Kbps',
+    bitrate: 720000,
+    codec: undefined,
+    original: false,
+  },
+  {
+    label: '360p - 420 Kbps',
+    bitrate: 420000,
+    codec: undefined,
+    original: false,
+  },
+];
+
+export function getClosestBitrate(qualities, bitrate) {
+  return qualities.reduce(
+    (prev, curr) =>
+      Math.abs(curr.bitrate - bitrate) < Math.abs(prev.bitrate - bitrate)
+        ? curr
+        : prev,
+    qualities[0],
+  );
+}
+
+export function formatTicksToTime(ticks: number) {
+  return formatMinutesToTime(ticks / 10_000_000 / 60);
+}
+
+export function formatMinutesToTime(minutes: number) {
+  const days = Math.floor(minutes / 60 / 24);
+  const hours = Math.floor((minutes / 60) % 24);
+  const minutesLeft = Math.floor(minutes % 60);
+
+  return `${days > 0 ? days + 'd ' : ''}${hours > 0 ? hours + 'h ' : ''}${
+    days > 0 ? '' : minutesLeft + 'min'
+  }`;
+}

backend/plugins/plugin-types.d.ts

@@ -40,6 +40,7 @@ export type Quality = {
   bitrate: number;
   label: string;
   codec: string | undefined;
+  original: boolean;
 };
 
 export type Subtitles = {
@@ -49,14 +50,26 @@ export type Subtitles = {
   codec: string | undefined;
 };
 
-export type VideoStream = {
+export type VideoStreamProperty = {
+  label: string;
+  value: string | number;
+  formatted: string | undefined;
+};
+
+export type VideoStreamCandidate = {
+  key: string;
+  title: string;
+  properties: VideoStreamProperty[];
+};
+
+export type VideoStream = VideoStreamCandidate & {
   uri: string;
   directPlay: boolean;
   progress: number;
   audioStreams: AudioStream[];
   audioStreamIndex: number;
   qualities: Quality[];
-  quality: number;
+  qualityIndex: number;
   subtitles: Subtitles[];
 };
 
@@ -93,10 +106,24 @@ export interface SourcePlugin {
 
   getMovieStream: (
     tmdbId: string,
+    key: string,
     context: UserContext,
     config?: PlaybackConfig,
   ) => Promise<VideoStream>;
 
+  getMovieStreams: (
+    tmdbId: string,
+    context: UserContext,
+    config?: PlaybackConfig,
+  ) => Promise<VideoStreamCandidate[]>;
+
+  getMovieStream: (
+    tmdbId: string,
+    context: UserContext,
+    key: string,
+    config?: PlaybackConfig,
+  ) => Promise<VideoStream>;
+
   getEpisodeStream: (
     tmdbId: string,
     season: number,

backend/src/source-plugins/source-plugins.controller.ts

@@ -21,12 +21,11 @@ import { Request, Response } from 'express';
 import { Readable } from 'stream';
 import { User } from 'src/users/user.entity';
 import { UserSourcesService } from 'src/users/user-sources/user-sources.service';
-import { PluginSettingsTemplate } from 'plugins/plugin-types';
 import {
   PlaybackConfigDto,
   PluginSettingsDto,
   PluginSettingsTemplateDto,
-  SourceListDto as VideoStreamListDto,
+  VideoStreamListDto,
   ValidationResponsekDto as ValidationResponseDto,
   VideoStreamDto,
 } from './source-plugins.dto';
@@ -97,48 +96,66 @@ export class SourcesController {
   }
 
   @ApiTags('movies')
-  @Get('movies/:tmdbId/sources')
+  @Get('movies/:tmdbId/sources/:sourceId/streams')
   @ApiOkResponse({
     description: 'Movie sources',
     type: VideoStreamListDto,
   })
-  async getMovieSources(
+  async getMovieStreams(
     @Param('tmdbId') tmdbId: string,
+    @Param('sourceId') sourceId: string,
     @GetUser() user: User,
     @GetAuthToken() token: string,
   ): Promise<VideoStreamListDto> {
-    if (!user) {
-      throw new UnauthorizedException();
+    const plugin = this.sourcesService.getPlugin(sourceId);
+
+    if (!plugin) {
+      throw new NotFoundException('Plugin not found');
     }
 
-    const plugins = await this.sourcesService.getPlugins();
-    const sources: VideoStreamListDto['sources'] = {};
+    const settings = this.userSourcesService.getSourceSettings(user, sourceId);
 
-    for (const pluginId in plugins) {
-      const plugin = plugins[pluginId];
-
-      if (!plugin) continue;
-
-      const settings = this.userSourcesService.getSourceSettings(
-        user,
-        pluginId,
-      );
-
-      if (!settings) continue;
-
-      const videoStream = await plugin.getMovieStream(tmdbId, {
-        settings,
-        token,
-      });
-
-      if (!videoStream) continue;
-
-      sources[pluginId] = videoStream;
+    if (!settings) {
+      throw new BadRequestException('Source configuration not found');
     }
 
+    const streams = await plugin.getMovieStreams(tmdbId, {
+      settings,
+      token,
+    });
+
     return {
-      sources,
+      streams,
     };
+
+    // const plugins = await this.sourcesService.getPlugins();
+    // const streams: VideoStreamListDto['streams'] = [];
+
+    // for (const pluginId in plugins) {
+    //   const plugin = plugins[pluginId];
+
+    //   if (!plugin) continue;
+
+    //   const settings = this.userSourcesService.getSourceSettings(
+    //     user,
+    //     pluginId,
+    //   );
+
+    //   if (!settings) continue;
+
+    //   const videoStream = await plugin.getMovieStreams(tmdbId, {
+    //     settings,
+    //     token,
+    //   });
+
+    //   if (!videoStream) continue;
+
+    //   streams[pluginId] = videoStream;
+    // }
+
+    // return {
+    //   streams,
+    // };
   }
 
   @ApiTags('movies')
@@ -148,14 +165,17 @@ export class SourcesController {
     type: VideoStreamDto,
   })
   async getMovieStream(
-    @Param('sourceId') sourceId: string,
     @Param('tmdbId') tmdbId: string,
+    @Param('sourceId') sourceId: string,
+    @Query('key') key: string,
     @GetUser() user: User,
     @GetAuthToken() token: string,
     @Body() config: PlaybackConfigDto,
   ): Promise<VideoStreamDto> {
-    if (!user) {
-      throw new UnauthorizedException();
+    const plugin = this.sourcesService.getPlugin(sourceId);
+
+    if (!plugin) {
+      throw new NotFoundException('Plugin not found');
     }
 
     const settings = this.userSourcesService.getSourceSettings(user, sourceId);
@@ -164,8 +184,9 @@ export class SourcesController {
       throw new BadRequestException('Source configuration not found');
     }
 
-    return this.sourcesService.getPlugin(sourceId)?.getMovieStream(
+    return plugin.getMovieStream(
       tmdbId,
+      key || '',
       {
         settings,
         token,
@@ -175,7 +196,7 @@ export class SourcesController {
   }
 
   @ApiTags('movies')
-  @All('movies/:tmdbId/sources/:sourceId/stream/*')
+  @All('movies/:tmdbId/sources/:sourceId/stream/proxy/*')
   async getMovieStreamProxy(
     @Param() params: any,
     @Req() req: Request,

backend/src/source-plugins/source-plugins.dto.ts

@@ -14,6 +14,8 @@ import {
   Subtitles,
   ValidationResponse,
   VideoStream,
+  VideoStreamCandidate,
+  VideoStreamProperty,
 } from 'plugins/plugin-types';
 import { DeviceProfileDto } from './device-profile.dto';
 
@@ -98,23 +100,6 @@ export class ValidationResponsekDto implements ValidationResponse {
   replace: Record<string, any>;
 }
 
-export class SourceDto {
-  @ApiProperty({ example: '/path/to/stream' })
-  uri: string;
-}
-
-export class SourceListDto {
-  @ApiProperty({
-    type: 'object',
-    additionalProperties: { $ref: getSchemaPath(SourceDto) },
-    example: {
-      source1: { uri: '/path/to/stream' },
-      source2: { uri: '/path/to/other/stream' },
-    },
-  })
-  sources: Record<string, VideoStreamDto>;
-}
-
 export class AudioStreamDto implements AudioStream {
   @ApiProperty()
   index: number;
@@ -141,6 +126,9 @@ export class QualityDto implements Quality {
 
   @ApiProperty({ required: false })
   codec: string | undefined;
+
+  @ApiProperty()
+  original: boolean;
 }
 
 export class SubtitlesDto implements Subtitles {
@@ -157,7 +145,34 @@ export class SubtitlesDto implements Subtitles {
   codec: string | undefined;
 }
 
-export class VideoStreamDto implements VideoStream {
+export class VideoStreamPropertyDto implements VideoStreamProperty {
+  @ApiProperty()
+  label: string;
+
+  @ApiProperty({
+    oneOf: [{ type: 'string' }, { type: 'number' }],
+  })
+  value: string | number;
+
+  @ApiProperty({ required: false })
+  formatted: string | undefined;
+}
+
+export class VideoStreamCandidateDto implements VideoStreamCandidate {
+  @ApiProperty()
+  key: string;
+
+  @ApiProperty()
+  title: string;
+
+  @ApiProperty({ type: [VideoStreamPropertyDto] })
+  properties: VideoStreamPropertyDto[];
+}
+
+export class VideoStreamDto
+  extends VideoStreamCandidateDto
+  implements VideoStream
+{
   @ApiProperty()
   uri: string;
 
@@ -177,7 +192,7 @@ export class VideoStreamDto implements VideoStream {
   qualities: QualityDto[];
 
   @ApiProperty()
-  quality: number;
+  qualityIndex: number;
 
   @ApiProperty({ type: [SubtitlesDto] })
   subtitles: SubtitlesDto[];
@@ -203,3 +218,10 @@ export class PlaybackConfigDto implements PlaybackConfig {
   @ApiPropertyOptional({ example: 'en', required: false })
   defaultLanguage: string | undefined;
 }
+
+export class VideoStreamListDto {
+  @ApiProperty({
+    type: [VideoStreamCandidateDto],
+  })
+  streams: VideoStreamCandidateDto[];
+}