Readonly outputCameraKitSession renders video output to a <canvas> element. In fact, each session contains two canvas outputs
corresponding to the RenderTargets used by Lens creators, when using LensStudio to create a Lens.
The live output renders content suitable for the Lens user (e.g. it may contain additional UI elements
applicable only to the person applying the lens). The capture output renders content suitable for sharing with
other users (e.g. sent to the other members of a video call, or saved to disk for sharing later).
For many lenses, these outputs are identical – but each lens is free to render differently, based on its own use-case.
Indicates whether or not the session is currently rendering. If false, rendering is stopped. Otherwise the
value indicates which output is being rendered.
Readonly eventsAdd event listeners here to handle events which occur during the CameraKitSession.
Note: Applications may want to handle the error event, and check the contained error type -- if the type
is LensExecutionError, this means the current lens was unable to render and CameraKit will automatically
remove the lens.
cameraKitSession.events.addEventListener('error', ({ detail }) => {
if (detail.error.name === 'LensExecutionError') {
console.log(`Lens ${detail.lens.name} encountered an error and was removed. Please pick a different lens.`)
}
})
Readonly metricsUse this to measure current lens performance.
Readonly keyboardUse this to interact with lenses which require text input.
Apply a Lens to this session.
This method will download (and cache) the Lens executable, and then use that Lens for rendering. If the session is currently playing, this will immediately update the rendered output. Otherwise, the new Lens will be used when session playback in resumed.
Calling applyLens replaces any prior Lens – only one Lens is allowed at a time (per session).
NOTE: Errors may occur after the Lens is applied. If the Lens encounters errors while rendering, Camera Kit will automatically remove the Lens from the session and emit a LensExecutionError event. Applications may want to listen for this error and, for example, prevent the Lens from being selected again by the user.
session.events.addEventListener("error", ({ detail }) => {
if (detail.error.name === "LensExecutionError") {
preventFutureLensSelection(detail.lens);
showMessage("We're sorry, but the Lens you selected encountered an error. Please choose a different Lens.");
}
});
The Lens to apply to this session.
Optional launchParams: LensLaunchParamsA promise which can have the following results:
true: the lens has been applied.false: the lens has not been applied, but no error occurred – this can happen if a
subsequent call to applyLens interrupted the lens application.Remove a Lens from this session.
When a Lens is removed, rendering continues if the session is playing. It will just render the session input directly to the outputs without any image processing.
A promise which can have the following results:
true: the session's rendered output has no lens applied.false: the current lens has been removed, but a subsequent call to applyLens means that the
session's rendered output will still have a (new) lens applied.Start/resume session playback – LensCore will begin rendering frames to the output.
If no source has been set for the session, calling play() will update the playing state, but no actual image
processing will occur until setSource() is called.
Specify the RenderTarget to render. Defaults to the live RenderTarget.
Promise resolves when playback state has been updated. If no source has been set, this means play will
resolve before any frames are processed -- but once a source is set, frames will immediately begin processing.
const cameraKitSession = await cameraKit.createSession()
await cameraKitSession.setSource(mySource)
await cameraKitSession.play()
// If you call `play` before `setSource`, the call to `play` will resolve but playback will only begin once a
// media source has been set.
Pause session playback – LensCore will stop rendering frames to the output.
Specify the RenderTarget to pause playback. May be either 'live' or 'capture'.
Default is 'live'.
Promise resolves when playback has stopped.
Set the media source for this session.
Sessions may only have one source at a time - if setSource is called multiple times, subsequent calls replace
the prior source. Setting the source does not trigger rendering (that’s done by session.play()). If the session
is already playing, setting the source will immediately begin rendering the new source.
The CameraKit SDK provides implementations for various common sources, which applications can create using the following functions:
A CameraKitSource object representing input media (e.g. a webcam stream, video, or some other source of image data), which CameraKit will supply to Lenses in order for them to render effects on top of that source.
Promise is resolved when the source has successfully be set. If the session was already in the playing state, the Promise resolves when the first frame from the new source has been rendered. The resolved value is the CameraKitSource object attached to the session.
Deprecated: Support for CameraKitDeviceInfo will be removed in future releases. Please use CameraKitDeviceOptions instead which accepts the "environment" and "user" cameraType
Optional options: Partial<CameraKitDeviceInfo>Optional options: Partial<CameraKitDeviceOptions>Set an FPS limit.
This may be useful to reduce CPU/GPU resource usage by CameraKit if, for example, the input media source has a low FPS – CameraKit would then not try to render more frequently than the source produces new frames.
This may also be useful to gracefully degrade performance in situations where lowering FPS is preferable over alternatives.
A maximum FPS, rendering will not exceed this limit
Promise is resolved when the limit is successfully set.
Generated using TypeDoc
A CameraKitSession represents a single rendering pipeline connecting an input media source to output
<canvas>elements. When a Lens is applied to the session, CameraKit uses the Lens to transform the input media into rendered output.CameraKitSession is the primary object that applications interact with when integrating the CameraKit SDK.
A CameraKitSession instance is obtained by calling createSession.
Example