Skip to main content
Version: 4.2.x

xdk-device-playstation-msdk

@accedo/xdk-device-playstation-msdk​

XDK4 Playstation MSDK

Instalation​

$ npm i @accedo/xdk-device-playstation-msdk

Usage​

import  playstationMsdk, {ID as PLAYSTATION_MSDK}  from '@accedo/xdk-device-playstation-msdk' ;

// Setup the device configuration
playstationMsdk.addPlayer(
  // imported player config
);

// include the device configuration into the packages to be detected and loaded
const devices = {
  packages: [
    // ...
    playstationMsdk
    // ...
  ],
  detail: {
    [PLAYSTATION_MSDK]: [
      extensions: [
        // add extensions
      ]
    ]
  }

References​

The documentation used to build this package is downloaded from the SDK Manager. You can get more info on how to Download the SDK in the PlayStation 5 DevNet portal

There's also a company Confluence page on PS5 with information about and link to the MSDK and doc and also some details about creating packages.

Libraries​

In the SDK manager we also find the required libs for the player implementation.

Capabilities matrix​

ModuleActionTypeSubtypeImplementedSupportedNotes
PlayerPlaybackHLSVOD, LiveVOD, Live
PlaybackDASHVOD, LiveVOD, Live
PlaybackSSVOD, Live*VOD, LiveUndocumented, *Not Tested
PlaybackMP4VODVOD
DRMHLSPlayReadyVOD, LiveVOD, LiveNot Tested
DRMDASHPlayReadyVOD, Live*VOD, Live*Not Tested
DRMSSPlayReadyVOD, Live*VOD, LiveUndocumented, *Not Tested
SubtitlesHLSInternalInternalInternal
SubtitlesDASHInternalInternal
Audio TracksHLSSupportedSupported
Audio TracksDASHSupportedSupported
SystemUUIDDASHSupportedSupported
Device TypeSupportedSupported
Audio TracksSupportedSupported
NetworkgetConnectionStatusSupportedSupported
StorageLocal, Session, CookiesLocal, Session, Cookies
TVKeySupportedSupported
PSNetworkNot ImplementedSupported
CommerceNot ImplementedSupported
AccesibilityNot ImplementedSupported

Playback​

The Player implementation for Playstation MSDK is implemented in order to work in the same way as any other abstraction layer. Only important thing to know is that there's some params for the player load method that needs to be taked into consideration:

  • type: mandatory param for identify which specific player library to use
  • drmURL: optional param when content includes DRM with the license server url.
  • drm: optional param when content includes DRM. Only valid value is playready
  • licenseRequest: optional param when content includes DRM. internal param, check PlayreadyDRMAgent.
  • licenseRelease: optional param when content includes DRM. internal param, check PlayreadyDRMAgent.
  • distinctiveIdentifier: optional param when content includes DRM. internal param, check PlayreadyDRMAgent.
  • persistentState: optional param when content includes DRM. internal param, check PlayreadyDRMAgent.
  • sessionTypes: optional param when content includes DRM. internal param, check PlayreadyDRMAgent.
  • esvm: optional param when content includes HDR. internal param, check PlayreadyDRMAgent.

Sample code​

import { mediaManager } from '@accedo/xdk-core';
[...]
mediaManager.getMedia(mediaInstanceId).then(mediaFromMgr => {
  Media = mediaFromMgr;
});
[...]
Media.load(url, {
  type: 'dash',
  drmURL: 'https://amssamples.keydelivery.mediaservices.windows.net/PlayReady/',
  drm: 'playready'
});
Media.play();

Player Styles (CSS)​

MSDK sample includes a couple of css files (sce-uvp.css and sce-uvp-controls.css) that are included in the abstraction layer under /src/api/lib but that are not included in order to avoid any collision with the application styles. Read those file in order to understand which styles may be needed in your application in order to work.

It is important to understand that the current implementation creates the player inside the parentNode included as an option when creating the player as in:

Media.load(url, {
  parentNode: desiredParentNode
});

In case of not defined a parent node, a new node will be created under body

The html structure generated is as follow:

<div class="sce-uvp">
  <div class="sce-uvp-inner-container">
    <div class="sce-uvp-player-container">
      <video></video>
    </div>
  </div>
</div>

Important Notes​

getUniqueId usage​

In order to be able to use the current getUniqueId implementation you need to be sure to follow up with Sony team in devnet as indicated (If you need to use this API in your application, contact SIE on DevNet.) in the documentation Media_SDK_Web_Launcher-Reference_e.pdf and review the following:

1. ID format changes attendant upon hardware change
Changes to the PS5 hardware may occur which could change the format of some hardware-dependent IDs such as the MAC address. Does your software perform processing of any hardware-dependent IDs in a way which could malfunction (e.g. cause compatibility breaks or other defects) as a result of a hardware change - for example, parsing the hardware ID?

2. Hardware dependency
In case of a hardware malfunction, a user may access your software using substitute hardware, or may acquire new hardware to replace their existing model. Is your software hardware-dependent in any way - does it display inconsistent behavior or cause disadvantage to the user if new hardware is used? Does the user need to perform any additional action as a result of a hardware change?

3. User dependency
Multiple users may make use of a single device, and the device itself may be owned by multiple users over its lifetime. We recommend using hardware IDs in combination with user IDs such as the SEN Online ID. Does your software rely solely upon hardware-dependent IDs for operation? That is, does it perform properly without inconsistent behavior or disadvantage to the user when played by different users?

4. Bound data
Save data is not bound to the user's device - it may be transferred to other devices. Other types of data may also be transferred to other devices. Does your software store the hardware ID in writable data which may be transferred?
Example Answer: The software does not store the hardware-dependent ID in data which may be transferred to another device.

5. Transmission over a network
Sony considers hardware IDs such as the OpenPSID, DUID, or MAC address to be personally identifiable information. Such information must be handled securely when transferred over a network to avoid man-in-the-middle attacks. Does your software authenticate the receiving device prior to transmission, and encrypt the information prior to transmission or use a secure transmission protocol when transferring hardware ID information?

6. Management of collected IDs on server
As hardware IDs are considered personally identifiable, the information must also be stored securely when managed on your servers. Is access to the hardware ID within your database limited to authorized individuals and are measures in place to prevent leakage of that data to external individuals?

7. Mission-critical use of hardware IDs
OpenPSIDs, DUIDs, and MAC addresses are shared by all titles on a given machine and not separated by title. Therefore it is possible that these IDs will be revealed by another party and exploited in your own systems, and it is also possible that a leak from a separate source could compromise the security of your own data.
Does your software address these risks in its usage of the IDs? For example, rather than making use of the unmodified hardware IDs, do you securely encrypt the IDs before storage with a key specific to your software, and/or add an HMAC to your system and only make use of the encrypted & verified ID?
In addition, Sony cannot guarantee perfect consistency of these IDs even if approval is given to use them. Therefore we cannot approve the use of these hardware IDs for mission-critical uses such as strict copy protection or user management.

8. Display of OpenPSIDs
You may not display OpenPSIDs or DUIDs within your software. Does your software display OpenPSIDs or DUIDs?

9. Management of acquired IDs
It may be possible at some point to extract data from save data files or local storage. Does your software store the hardware ID in local storage, and if it does store hardware IDs locally on the device or on a connected PC, does your software securely manage hardware IDs?

10. Using hardware IDs for Console Banning
Does your software use hardware IDs for the purposes of banning consoles?

If you don't get the approval the alternative way is using the implementation in xdk-core storageUniqueId.

import {
  storageUniqueId
} from '@accedo/xdk-core';
[...]
console.log(storageUniqueId.getUniqueId());

Package Creation​

This abstraction layer includes a sample package folder in platforms/playstation-msdk with the following:

  • eboot.bin: required for package running (development)
  • package.gp5: required for package creation that includes references to the files in sce_sys
  • sce_sys/icon0.png: App Logo (512x512)
  • sce_sys/param.json: List of params of the application

The list of params and values for the package.gp5 has been taked based on the following documentation:

In order to create a final package for submission or instalation you will need to use the MSDK included cmd:

prospero-pub-cmd.exe img_create package.gp5 package.pkg

DRM Support Limitations​

  1. Playstation 5 doesn't support the #EXT-X-PLAYREADYHEADER tag in HLS+PR streams

  2. Only streams without token has been tested sucessfully