WebRTC Encoded Transform

1. Introduction

The [WEBRTC-NV-USE-CASES] document describes several functions that can only be achieved by access to media (requirements N20-N22), including, but not limited to:

• Funny Hats

• Machine Learning

• Virtual Reality Gaming

These use cases further require that processing can be done in worker threads (requirement N23-N24).

Furthermore, the "trusted JavaScript cloud conferencing" use case requires such processing to be done on encoded media, not just the raw media.

This specification gives an interface inspired by [WEB-CODECS] to provide access to such functionality while retaining the setup flow of RTCPeerConnection.

This iteration of the specification provides access to encoded media, which is the output of the encoder part of a codec and the input to the decoder part of a codec.

2. Terminology

3. Specification

The Streams definition doesn’t use WebIDL much, but the WebRTC spec does. This specification shows the IDL extensions for WebRTC.

It uses an additional API on RTCRtpSender and RTCRtpReceiver to insert the processing into the pipeline.

// New dictionary
dictionary RTCInsertableStreams {
    ReadableStream readable;
    WritableStream writable;
};
typedef (SFrameTransform or RTCRtpScriptTransform) RTCRtpTransform;
// New methods for RTCRtpSender and RTCRtpReceiver
partial interface RTCRtpSender {
    attribute RTCRtpTransform? transform;
};
partial interface RTCRtpReceiver {
    attribute RTCRtpTransform? transform;
};

3.1. Extension operation

At the time when a codec is initialized as part of the encoder, and the corresponding flag is set in the RTCPeerConnection 's RTCConfiguration argument, ensure that the codec is disabled and produces no output.

3.1.1. Stream creation

Each RTCRtpSender or RTCRtpReceiver has its own media thread on which media flows, from a source on which to read encoded data to a sink on which to write encoded data. The source is the packetizer for RTCRtpSender and the decoder for RTCRtpReceiver . It operates in the media thread and is modeled as a ReadableStream . The sink is the encoder for RTCRtpSender and the depacketizer for RTCRtpReceiver . It operates in the media thread and is modeled as a WritableStream .

At construction of each RTCRtpSender or RTCRtpReceiver , run the following steps:

1. Initialize this . [[transform]] to null. null .

2. Initialize this . [[readable]] [[lastReceivedFrameTimestamp]] to zero.

3. Initialize this . [[pipeToController]] to null .

4. Initialize this . [[source]] to a new ReadableStream .

5. Set up this . [[readable]] [[source]] . this . [[readable]] [[source]] is provided frames using the readEncodedData readSourceData algorithm given this as parameter.

6. Set this . [[readable]] . [[owner]] to this . Initialize this . [[writable]] [[sink]] to a new WritableStream .

7. Set up this . [[writable]] [[sink]] with its writeAlgorithm set to writeEncodedData writeSinkData given this as parameter.

8. Set this . [[writable]] . [[owner]] to this . Initialize this . [[pipeToController]] to null. Initialize this . [[lastReceivedFrameTimestamp]] Queue a task to zero. run the following step:

   1. Queue a task on this 's media thread to run the following steps:

      1. If this . [[pipeToController]] is not null, abort these steps.

      2. Set this . [[pipeToController]] to a new AbortController .

      3. Call pipeTo with this . [[readable]] [[source]] , this . [[writable]] [[sink]] , preventClose equal to true, preventAbort equal to true, preventCancel equal to true and this . [[pipeToController]] .signal.

3.1.2. Stream processing

The readEncodedData readSourceData algorithm is given a rtcObject as parameter. It is defined by running runs the following steps: steps in the media thread :

1. Wait for a frame to be produced by rtcObject ’s encoder if it is a RTCRtpSender or rtcObject ’s packetizer if it is a RTCRtpReceiver .

2. Let frame be the newly produced frame.

3. Set frame . [[owner]] to rtcObject .

4. Enqueue frame in rtcObject . [[readable]] [[source]] .

The writeEncodedData writeSinkData algorithm is given a rtcObject as parameter and a frame as input. It is defined by running runs the following steps: steps in the media thread :

1. If frame . [[owner]] is not equal to rtcObject , abort these steps and return a promise resolved with undefined. A processor cannot create frames, or move frames between streams.

2. If the frame ’s timestamp is equal to or larger than rtcObject . [[lastReceivedFrameTimestamp]] , abort these steps and return a promise resolved with undefined. A processor cannot reorder frames, although it may delay them or drop them.

3. Set rtcObject . [[lastReceivedFrameTimestamp]] to the frame ’s timestamp .

4. Enqueue the frame for processing as if it came directly from the encoded data source, by running one of the following steps: steps in the media thread :

   • If rtcObject is a RTCRtpSender , enqueue it to rtcObject ’s packetizer, to be processed in parallel . packetizer.

   • If rtcObject is a RTCRtpReceiver , enqueue it to rtcObject ’s decoder, to be processed in parallel . decoder.

5. Return a promise resolved with undefined.

3.2. Extension attribute

A RTCRtpTransform has two private slots called [[readable]] and [[writable]] .

The transform getter steps are:

1. Return this . [[transform]] .

The transform setter steps are:

1. Let transform be the argument to the setter.

2. Let checkedTransform set to If transform if it is not null or to an identity , run the following steps:

   1. If transform stream . [[readable]] is locked , throw otherwise. a TypeError .

   2. Let reader be the result of getting Get a reader writer for checkedTransform transform . [[readable]] [[writable]] .

   3. Let writer be the result of getting Get a writer reader for checkedTransform transform . [[writable]] [[readable]] .

3. Initialize Queue a task in this 's media thread to run the following steps:

   1. let newPipeToController pipeToController to be a new AbortController .

   2. If this Let internalTransform be an identity transform stream . [[pipeToController]] is not null, run the following steps:

   3. If transform is an Add SFrameTransform the chain , set internalTransform to an SFrame transform algorithm stream to this . [[pipeToController]] .signal. given transform .

   4. If transform is an signal abort RTCRtpScriptTransform this . [[pipeToController]] .signal. , set internalTransform to a script transform stream given transform .

   5. Else, run Run the chain transform algorithm steps. Set with this . , internalTransform . [[pipeToController]] [[readable]] , internalTransform . [[writable]] to and newPipeToController pipeToController .

4. Set this . [[transform]] to transform .

The chain transform algorithm , given rtcObject , readable , writable and pipeToController , runs these steps are defined as: in rtcObject’s media thread :

1. If newPipeToController pipeToController ’s aborted flag is true, abort these steps.

2. Release If reader rtcObject . [[pipeToController]] is not null , run the following steps:

   1. Release Add the chain transform algorithm with writer rtcObject , readable , writable and pipeToController , to rtcObject . [[pipeToController]] .signal.

   2. Assert that newPipeToController is the same object as signal abort rtcObject . [[pipeToController]] . .signal.

3. Else run the following steps:

   1. Call pipeTo with rtcObject . [[readable]] [[source]] , checkedTransform . [[writable]] , writable , preventClose equal to false, preventAbort equal to false, preventCancel equal to true and newPipeToController pipeToController .signal.

   2. Call pipeTo with checkedTransform . [[readable]] , readable , rtcObject . [[writable]] [[sink]] , preventClose equal to true, preventAbort equal to true, preventCancel equal to false and newPipeToController pipeToController .signal.

4. Set rtcObject . [[pipeToController]] to pipeToController .

This algorithm is defined so that transforms can be updated dynamically. There is no guarantee on which frame will happen the switch from the previous transform to the new transform. If a new transform overwrites an old transform, all frames will go either through the old or the new transform from the source to the sink.

If a web application sets the transform synchronously at creation of the RTCRtpSender (for instance when calling addTrack), the transform will receive the first frame generated by the RTCRtpSender 's encoder. Similarly, if a web application sets the transform synchronously at creation of the RTCRtpReceiver (for instance when calling addTrack, or at track event handler), the transform will receive the first full frame generated by the RTCRtpReceiver 's packetizer.

4. SFrameTransform

enum SFrameTransformRole {
    "encrypt",
    "decrypt"
};
dictionary SFrameTransformOptions {
    SFrameTransformRole role = "encrypt";
};
typedef [EnforceRange] unsigned long long SmallCryptoKeyID;
typedef (SmallCryptoKeyID or bigint) CryptoKeyID;
[Exposed=(Window,DedicatedWorker)]
interface SFrameTransform {
    constructor(optional SFrameTransformOptions options = {});
    Promise<undefined> setEncryptionKey(CryptoKey key, optional CryptoKeyID keyID);
};
;

SFrameTransform includes GenericTransformStream;

The new SFrameTransform( options ) constructor steps are:

1. Set this . [[role]] to options [" role "].

2. Let sframeTransform be a SFrame transform stream given this .

3. Set this . [[readable]] to sframeTransform . [[readable]] .

4. Set this . [[writable]] to sframeTransform . [[writable]] .

4.1. Algorithms

A SFrame transform stream given transform is created by running the following steps:

1. Let transformAlgorithm be an algorithm which takes a frame as input and runs the SFrame transform algorithm with this transform and frame .

2. Set this transform . [[transform]] [[sframeTransform]] to a new TransformStream .

3. Set up this . transform . [[transform]] [[sframeTransform]] with transformAlgorithm set to transformAlgorithm .

4. Let options be the method’s first argument. Set this . [[role]] to options [" role "]. Set this . [[readable]] to this . [[transform]] . [[readable]] . Set this . [[writable]] to Return this sframeTransform . [[transform]] . [[writable]] .

The SFrame transform algorithm, algorithm , given sframe sframeTransform as a SFrameTransform object and frame , runs these steps:

1. Let role be sframe sframeTransform . [[role]] .

2. If frame . [[owner]] is a RTCRtpSender , set role to 'encrypt'.

3. If frame . [[owner]] is a RTCRtpReceiver , set role to 'decrypt'.

4. Let data be undefined.

5. If frame is a BufferSource , set data to frame .

6. If frame is a RTCEncodedAudioFrame , set data to frame . data

7. If frame is a RTCEncodedVideoFrame , set data to frame . data

8. If data is undefined, abort these steps.

9. Let buffer be the result of running the SFrame algorithm with data and role as parameters. This algorithm is defined by the SFrame specification and returns an ArrayBuffer .

10. If frame is a BufferSource , set frame to buffer .

11. If frame is a RTCEncodedAudioFrame , set frame . data to buffer .

12. If frame is a RTCEncodedVideoFrame , set frame . data to buffer .

13. Enqueue frame in sframe sframeTransform . [[transform]] .

4.2. Methods

1. Let promise be a new promise .

2. If keyID is a bigint which cannot be represented as a integer between 0 and 2 ⁶⁴ -1 inclusive, reject promise with a RangeError exception.

3. Otherwise, in parallel , run the following steps:

   1. Set key with its optional keyID as key material to use for the SFrame transform algorithm, algorithm , as defined by the SFrame specification .

   2. If setting the key material fails, reject promise with an InvalidModificationError exception and abort these steps.

   3. Resolve promise with undefined.

4. Return promise .

5. RTCRtpScriptTransform

// New enum for video frame types. Will eventually re-use the equivalent defined
// by WebCodecs.
enum RTCEncodedVideoFrameType {
    "empty",
    "key",
    "delta",
};
dictionary RTCEncodedVideoFrameMetadata {
    long long frameId;
    sequence<long long> dependencies;
    unsigned short width;
    unsigned short height;
    long spatialIndex;
    long temporalIndex;
    long synchronizationSource;
    sequence<long> contributingSources;
};
// New interfaces to define encoded video and audio frames. Will eventually
// re-use or extend the equivalent defined in WebCodecs.
[Exposed=(Window,DedicatedWorker)]
interface RTCEncodedVideoFrame {
    readonly attribute RTCEncodedVideoFrameType type;
    readonly attribute unsigned long long timestamp;
    attribute ArrayBuffer data;
    RTCEncodedVideoFrameMetadata getMetadata();
};
dictionary RTCEncodedAudioFrameMetadata {
    long synchronizationSource;
    sequence<long> contributingSources;
};
[Exposed=(Window,DedicatedWorker)]
interface RTCEncodedAudioFrame {
    readonly attribute unsigned long long timestamp;
    attribute ArrayBuffer data;
    RTCEncodedAudioFrameMetadata getMetadata();
};
// New interfaces to expose JavaScript-based transforms.
[Exposed=DedicatedWorker]
interface RTCTransformEvent : Event {
    readonly attribute RTCRtpScriptTransformer transformer;
};
partial interface DedicatedWorkerGlobalScope {
    attribute EventHandler onrtctransform;
};
[Exposed=DedicatedWorker]
interface RTCRtpScriptTransformer {
    ;
    ;

    readonly attribute ReadableStream readable;
    readonly attribute WritableStream writable;
    readonly attribute any options;
};
[Exposed=Window]
interface RTCRtpScriptTransform {
    constructor(Worker worker, optional any options, optional sequence<object> transfer);
};

5.1. Operations

1. Set t1 to an identity transform stream . Set t2 to an identity transform stream . Set this . [[writable]] to t1 . [[writable]] . Set this . [[readable]] [[worker]] to t2 worker . [[readable]] .

2. Let serializedOptions be the result of StructuredSerializeWithTransfer ( options , transfer ).

3. Let serializedReadable be the result of StructuredSerializeWithTransfer ( t1 . [[readable]] , « t1 . [[readable]] »). Let serializedWritable be the result of StructuredSerializeWithTransfer ( t2 . [[writable]] , « t2 . [[writable]] »). Queue a task on the DOM manipulation task source worker ’s global scope to run the following steps:

   1. Let transformerOptions transformer be the result of StructuredDeserialize a new RTCRtpScriptTransformer ( serializedOptions , the current Realm). .

   2. Let readable transformerOptions be the result of StructuredDeserialize ( serializedReadable serializedOptions , the current Realm).

   3. Let Set writable be the result of StructuredDeserialize ( transformer . [[options]] to serializedWritable , the current Realm). transformerOptions .

   4. Let transformer be a new RTCRtpScriptTransformer . . [[t1]] to an identity transform stream .

   5. Set Let transformer . [[options]] [[t2]] to transformerOptions . an identity transform stream .

   6. Set transformer . [[readable]] to readable transformer . [[t1]] . [[readable]] .

   7. Set transformer . [[writable]] to writable transformer . [[t2]] . [[writable]] .

   8. Let event be the result of creating an event with RTCTransformEvent .

   9. Set event .type attribute to "rtctransform".

   10. Set event .transformer to transformer .

   11. Set this . [[transformer]] to transformer .

   12. Dispatch event on to worker ’s global scope.

// FIXME: Describe error handling (worker closing flag true at RTCRtpScriptTransform creation time. And worker being terminated while transform is processing data).

A script transform stream given transform is created by running the following steps:

1. Set t1 to an identity transform stream .

2. Set t2 to an identity transform stream .

3. Set scriptTransform . [[writable]] to t1 . [[writable]] .

4. Set scriptTransform . [[readable]] to t2 . [[readable]] .

5. Let serializedReadable be the result of StructuredSerializeWithTransfer ( t1 . [[readable]] , « t1 . [[readable]] »).

6. Let serializedWritable be the result of StructuredSerializeWithTransfer ( t2 . [[writable]] , « t2 . [[writable]] »).

7. Queue a task on the DOM manipulation task source transform . [[worker]] 's global scope to run the following steps:

   1. Let readable be the result of StructuredDeserialize ( serializedReadable , the current Realm).

   2. Let writable be the result of StructuredDeserialize ( serializedWritable , the current Realm).

   3. Call pipeTo with readable , transform . [[transformer]] . [[t1]] . [[writable]] .

   4. Call pipeTo with transform . [[transformer]] . [[t2]] . [[readable]] and writable .

8. Return scriptTransform .

5.2. Attributes

A RTCRtpScriptTransformer has three private slots called [[options]] , [[readable]] and [[writable]] .

The options getter steps are:

1. Return this . [[options]] .

The readable getter steps are:

1. Return this . [[readable]] .

The writable getter steps are:

1. Return this . [[writable]] .

6. Privacy and security considerations

This API gives Javascript access to the content of media streams. This is also available from other sources, such as Canvas and WebAudio.

However, streams that are isolated (as specified in [WEBRTC-IDENTITY] ) or tainted with another origin, cannot be accessed using this API, since that would break the isolation rule.

The API will allow access to some aspects of timing information that are otherwise unavailable, which allows some fingerprinting surface.

The API will give access to encoded media, which means that the JS application will have full control over what’s delivered to internal components like the packetizer or the decoder. This may require additional care with auditing how data is handled inside these components.

For instance, packetizers may expect to see data only from trusted encoders, and may not be audited for reception of data from untrusted sources.

7. Examples

See the explainer document .