Class Player

isPlaying

• get isPlaying(): boolean

  Returns boolean

addEventListener

• addEventListener<E extends EventKey<PlayerEventMap>>(
      event: E,
      listener: EventListener<PlayerEventMap[E]>,
      options?: boolean | AddEventListenerOptions,
  ): void

  Type Parameters

  • E extends EventKey<PlayerEventMap>

  Parameters

  • event: E
  • listener: EventListener<PlayerEventMap[E]>
  • Optionaloptions: boolean | AddEventListenerOptions

  Returns void

addModule

• addModule(...modules: Module[]): Promise<void>

  Adds additional modules like face_tracker, background and many others to the Player and makes them available for effects

  Parameters

  • ...modules: Module[]

  Returns Promise<void>

  Example

  const frx = new Module("/path/to/face_tracker.zip")
  
  await player.addModule(frx)
  Copy

applyEffect

• applyEffect(effect: Effect): Promise<BanubaSDK.Effect>

  Applies an effect to input

  Parameters

  • effect: Effect

  Returns Promise<BanubaSDK.Effect>

  Example

  const octopus = new Effect("/path/to/Octopus.zip")
  
  await player.applyEffect(octopus)
  Copy

callJsMethod

• callJsMethod(methodName: string, methodJSONParams?: string): Promise<void>

  Evaluates JavaScript in context of applied effect.

  Parameters

  • methodName: string
  • methodJSONParams: string = ""

  Returns Promise<void>

  Deprecated

  Use Effect.evalJs instead.

clearEffect

• clearEffect(): Promise<void>

  Clears effect applied to input

  Returns Promise<void>

destroy

• destroy(): Promise<void>

  Destroys the Player instance, clears all the resources used

  Returns Promise<void>

pause

• pause(): void

  Stops input processing

  Returns void

play

• play(options?: PlaybackOptions): void

  Starts input processing.

  Accepts playback options object with optional fps and pauseOnEmpty keys.

  Parameters

  • options: PlaybackOptions = {}

  Returns void

  Example

  /// The `fps` playback option persists between invocations:
  
  const desiredFps = 25
  
  player.play({ fps: desiredFps })
  player.play() // same as passing `{ fps: desiredFps }`
  Copy

  Example

  /// The `pauseOnEmpty` playback option resets to `true` between invocations:
  
  await player.use(new Image(file))
  player.applyEffect(new Effect("path/to/Spider.zip")) // an effect with animations
  
  player.play({ pauseOnEmpty: false })
  player.play() // same as passing `{ pauseOnEmpty: true }`
  Copy

removeEventListener

• removeEventListener<E extends EventKey<PlayerEventMap>>(
      event: E,
      listener: EventListener<PlayerEventMap[E]>,
      options?: boolean | EventListenerOptions,
  ): void

  Type Parameters

  • E extends EventKey<PlayerEventMap>

  Parameters

  • event: E
  • listener: EventListener<PlayerEventMap[E]>
  • Optionaloptions: boolean | EventListenerOptions

  Returns void

setVolume

• setVolume(level: number): void

  Sets effect volume from 0 to 1

  Parameters

  • level: number

  Returns void

use

• use(input: Input, options?: InputOptions): void

  Uses the input as frames source

  Parameters

  • input: Input
  • Optionaloptions: InputOptions

  Returns void

  Example

  player.use(new Webcam())
  Copy

Staticcreate

• create(options: SDKOptions & PlayerOptions): Promise<Player>

  Creates Player instance.

  See SDKOptions and PlayerOptions for all the possible parameters.

  Parameters

  • options: SDKOptions & PlayerOptions

  Returns Promise<Player>

  Example

  const player = await Player.create({ clientToken: "xxx-xxx-xxx", devicePixelRatio: 1 })
  Copy

Static ReadonlyEFFECT_ACTIVATED_EVENT

Static ReadonlyFRAME_DATA_EVENT

player.addEventListener("framedata", ({ detail: frameData }) => {
  const hasFace = frameData.get("frxRecognitionResult.faces.0.hasFace")
  if (!hasFace) return

  const landmarks = frameData.get("frxRecognitionResult.faces.0.landmarks")
  console.log(landmarks)
})
Copy

Static ReadonlyFRAME_PROCESSED_EVENT

Static ReadonlyFRAME_RECEIVED_EVENT

Static ReadonlyFRAME_RENDERED_EVENT