index.bs

<pre class='metadata'>
Title: WebRTC Encoded Transform
Shortname: webrtc-encoded-transform
Level: None
Status: ED
Group: webrtc
TR: https://www.w3.org/TR/webrtc-encoded-transform/
Repository: w3c/webrtc-encoded-transform
URL: https://w3c.github.io/webrtc-encoded-transform/
Editor: Harald Alvestrand, w3cid 24610 , Google https://google.com, hta@google.com
Editor: Guido Urdaneta, w3cid 84810, Google https://google.com, guidou@google.com
Editor: Youenn Fablet, w3cid 96458, Apple https://www.apple.com, youenn@apple.com
Abstract: This API defines an API surface for manipulating the bits on
Abstract: {{MediaStreamTrack}}s being sent via an {{RTCPeerConnection}}.
Markup Shorthands: css no, markdown yes
</pre>
<pre class=link-defaults>
spec:webidl; type:dfn; text:resolve
</pre>
<pre class=biblio>
{
  "WEB-CODECS": {
     "href":
     "https://github.com/WICG/web-codecs/blob/master/explainer.md",
     "title": "Web Codecs explainer"
   },
  "SFRAME": {
     "href":
     "https://www.ietf.org/archive/id/draft-ietf-sframe-enc-00.html",
     "title": "Secure Frame (SFrame)"
   }
}
</pre>
<pre class=link-defaults>
spec:streams; type:interface; text:ReadableStream
</pre>

# Introduction # {#introduction}

The [[WEBRTC-NV-USE-CASES]] document describes the use-case of
    * Untrusted JavaScript Cloud Conferencing
which requires that the conferencing server does not have access
to the cleartext media (requirement N27).

This 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 which allows the user agent to apply encryption
locally.

The interface is inspired by [[WEB-CODECS]] to
provide access to such functionality while retaining the setup flow of
RTCPeerConnection

# Terminology # {#terminology}

# Specification # {#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.

<pre class="idl">
typedef (SFrameTransform or RTCRtpScriptTransform) RTCRtpTransform;

// New methods for RTCRtpSender and RTCRtpReceiver
partial interface RTCRtpSender {
    attribute RTCRtpTransform? transform;
};

partial interface RTCRtpReceiver {
    attribute RTCRtpTransform? transform;
};
</pre>

## Extension operation ## {#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.


### Stream creation ### {#stream-creation}

At construction of each {{RTCRtpSender}} or {{RTCRtpReceiver}}, run the following steps:
2. Initialize [=this=].`[[transform]]` to null.
3. Initialize [=this=].`[[readable]]` to a new {{ReadableStream}}.
4. <a dfn for="ReadableStream">Set up</a> [=this=].`[[readable]]`. [=this=].`[[readable]]` is provided frames using the [=readEncodedData=] algorithm given |this| as parameter.
5. Set [=this=].`[[readable]]`.`[[owner]]` to |this|.
6. Initialize [=this=].`[[writable]]` to a new {{WritableStream}}.
7. <a dfn for="WritableStream">Set up</a> [=this=].`[[writable]]` with its [=WritableStream/set up/writeAlgorithm=] set to [=writeEncodedData=] given |this| as parameter and its [=WritableStream/set up/sizeAlgorithm=] to an algorithm that returns <code>0</code>.
    <p class="note">Chunk size is set to 0 to explictly disable streams backpressure on the write side.</p>
8. Set [=this=].`[[writable]]`.`[[owner]]` to |this|.
9. Initialize [=this=].`[[pipeToController]]` to null.
1. Initialize [=this=].`[[lastReceivedFrameCounter]]` to <code>0</code>.
1. Initialize [=this=].`[[lastEnqueuedFrameCounter]]` to <code>0</code>.
1. [=Queue a task=] to run the following steps:
    1. If [=this=].`[[pipeToController]]` is not null, abort these steps.
    2. Set [=this=].`[[pipeToController]]` to a new {{AbortController}}.
    <!-- FIXME: Use pipeTo algorithm when available. -->
    3. Call <a href="https://streams.spec.whatwg.org/#readable-stream-pipe-to">pipeTo</a> with [=this=].`[[readable]]`, [=this=].`[[writable]]`, preventClose equal to true, preventAbort equal to true, preventCancel equal to true and [=this=].`[[pipeToController]]`.signal.

### Stream processing ### {#stream-processing}

The <dfn>readEncodedData</dfn> algorithm is given a |rtcObject| as parameter. It is defined by running the following steps:
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}}.
1. Increment |rtcObject|.`[[lastEnqueuedFrameCounter]]` by <code>1</code>.
1. Let |frame| be the newly produced frame.
1. Set |frame|.`[[owner]]` to |rtcObject|.
1. Set |frame|.`[[counter]]` to |rtcObject|.`[[lastEnqueuedFrameCounter]]`.
1. [=ReadableStream/Enqueue=] |frame| in |rtcObject|.`[[readable]]`.

The <dfn>writeEncodedData</dfn> algorithm is given a |rtcObject| as parameter and a |frame| as input. It is defined by running the following steps:
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.
1. If |frame|.`[[counter]]` is equal or smaller than |rtcObject|.`[[lastReceivedFrameCounter]]`, abort these steps and return [=a promise resolved with=] undefined. A processor cannot reorder frames, although it may delay them or drop them.
1. Set |rtcObject|.`[[lastReceivedFrameCounter]]` to |frame|`[[counter]]`.
1. Let |data| be |frame|.`[[data]]`.
1. Let |serializedFrame| be [$StructuredSerializeWithTransfer$](|frame|, « |data| »).
1. Let |frameCopy| be [$StructuredDeserialize$](|serializedFrame|,  |frame|'s [=relevant realm=]).
1. Enqueue |frameCopy| for processing as if it came directly from the encoded data source, by running one of the following steps:
    * If |rtcObject| is a {{RTCRtpSender}}, enqueue |frameCopy| to |rtcObject|'s packetizer, to be processed [=in parallel=].
    * If |rtcObject| is a {{RTCRtpReceiver}}, enqueue |frameCopy| it to |rtcObject|'s decoder, to be processed [=in parallel=].
1. Return [=a promise resolved with=] undefined.

On sender side, as part of [=readEncodedData=], frames produced by |rtcObject|'s encoder MUST be enqueued in |rtcObject|.`[[readable]]` in the encoder's output order.
As [=writeEncodedData=] ensures that the transform cannot reorder frames, the encoder's output order is also the order followed by packetizers to generate RTP packets and assign RTP packet sequence numbers.

On receiver side, as part of [=readEncodedData=], frames produced by |rtcObject|'s packetizer MUST be enqueued in |rtcObject|.`[[readable]]` in the same encoder's output order.
To ensure the order is respected, the depacketizer will typically use RTP packet sequence numbers to reorder RTP packets as needed before enqueuing frames in |rtcObject|.`[[readable]]`.
As [=writeEncodedData=] ensures that the transform cannot reorder frames, this will be the order expected by |rtcObject|'s decoder.

## Extension attribute ## {#attribute}

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

Each RTCRtpTransform has an <dfn>association steps</dfn> set, which is empty by default.

The <dfn attribute for="RTCRtpSender,RTCRtpReceiver">transform</dfn> getter steps are:
1. Return [=this=].`[[transform]]`.

The `transform` setter steps are:
2. Let |transform| be the argument to the setter.
3. Let |checkedTransform| set to |transform| if it is not null or to an [=identity transform stream=] otherwise.
3. Let |reader| be the result of [=ReadableStream/getting a reader=] for |checkedTransform|.`[[readable]]`.
4. Let |writer| be the result of [=WritableStream/getting a writer=] for |checkedTransform|.`[[writable]]`.
5. Initialize |newPipeToController| to a new {{AbortController}}.
6. If [=this=].`[[pipeToController]]` is not null, run the following steps:
    1. [=AbortSignal/Add=] the [=chain transform algorithm=] to [=this=].`[[pipeToController]]`.signal.
    2. [=AbortSignal/signal abort=] [=this=].`[[pipeToController]]`.signal.
7. Else, run the [=chain transform algorithm=] steps.
8. Set [=this=].`[[pipeToController]]` to |newPipeToController|.
9. Set [=this=].`[[transform]]` to |transform|.
10. Run the steps in the set of [=association steps=] of |transform| with [=this=].

The <dfn>chain transform algorithm</dfn> steps are defined as:
1. If |newPipeToController| is [=AbortSignal/aborted=], abort these steps.
2. [=ReadableStreamDefaultReader/Release=] |reader|.
3. [=WritableStreamDefaultWriter/Release=] |writer|.
4. Assert that |newPipeToController| is the same object as |rtcObject|.`[[pipeToController]]`.
<!-- FIXME: Use pipeTo algorithm when available. -->
5. Call <a href="https://streams.spec.whatwg.org/#readable-stream-pipe-to">pipeTo</a> with |rtcObject|.`[[readable]]`, |checkedTransform|.`[[writable]]`, preventClose equal to false, preventAbort equal to false, preventCancel equal to true and |newPipeToController|.signal.
6. Call <a href="https://streams.spec.whatwg.org/#readable-stream-pipe-to">pipeTo</a> with |checkedTransform|.`[[readable]]`, |rtcObject|.`[[writable]]`, preventClose equal to true, preventAbort equal to true, preventCancel equal to false and |newPipeToController|.signal.

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 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.

# SFrameTransform # {#sframe}

<p>
The API presented in this section allows applications to process SFrame data as defined in [[SFrame]].
</p>

<xmp class="idl">
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);
    attribute EventHandler onerror;
};
SFrameTransform includes GenericTransformStream;

enum SFrameTransformErrorEventType {
    "authentication",
    "keyID",
    "syntax"
};

[Exposed=(Window,DedicatedWorker)]
interface SFrameTransformErrorEvent : Event {
    constructor(DOMString type, SFrameTransformErrorEventInit eventInitDict);

    readonly attribute SFrameTransformErrorEventType errorType;
    readonly attribute CryptoKeyID? keyID;
    readonly attribute any frame;
};

dictionary SFrameTransformErrorEventInit : EventInit {
    required SFrameTransformErrorEventType errorType;
    required any frame;
    CryptoKeyID? keyID;
};
</xmp>

The <dfn constructor for="SFrameTransform" lt="SFrameTransform(options)"><code>new SFrameTransform(<var>options</var>)</code></dfn> constructor steps are:
1. Let |transformAlgorithm| be an algorithm which takes a |frame| as input and runs the <a href="#sframe-transform-algorithm">SFrame transform algorithm</a> with |this| and |frame|.
2. Set |this|.`[[transform]]` to a new {{TransformStream}}.
3. <a dfn for="ReadableStream">Set up</a> [=this=].`[[transform]]` with [=TransformStream/set up/transformAlgorithm=] set to |transformAlgorithm|.
4. Let |options| be the method's first argument.
5. Set |this|.`[[role]]` to |options|["{{SFrameTransformOptions/role}}"].
6. Set |this|.`[[readable]]` to |this|.`[[transform]]`.`[[readable]]`.
7. Set |this|.`[[writable]]` to |this|.`[[transform]]`.`[[writable]]`.

## Algorithm ## {#sframe-transform-algorithm}

The SFrame transform algorithm, given |sframe| as a SFrameTransform object and |frame|, runs these steps:
1. Let |role| be |sframe|.`[[role]]`.
1. If |frame|.`[[owner]]` is a {{RTCRtpSender}}, set |role| to 'encrypt'.
1. If |frame|.`[[owner]]` is a {{RTCRtpReceiver}}, set |role| to 'decrypt'.
1. Let |data| be undefined.
1. If |frame| is a {{BufferSource}}, set |data| to |frame|.
1. If |frame| is a {{RTCEncodedAudioFrame}}, set |data| to |frame|.{{RTCEncodedAudioFrame/data}}
1. If |frame| is a {{RTCEncodedVideoFrame}}, set |data| to |frame|.{{RTCEncodedVideoFrame/data}}
1. If |data| is undefined, abort these steps.
1. Let |buffer| be the result of running the SFrame algorithm with |data| and |role| as parameters. This algorithm is defined by the <a href="https://datatracker.ietf.org/doc/draft-omara-sframe/">SFrame specification</a> and returns an {{ArrayBuffer}}.
1. If the SFrame algorithm exits abruptly with an error, [=queue a task=] to run the following sub steps:
     1. If the processing fails on decryption side due to |data| not following the SFrame format, [=fire an event=] named {{SFrameTransform/onerror|error}} at |sframe|,
        using the {{SFrameTransformErrorEvent}} interface with its {{SFrameTransformErrorEvent/errorType}} attribute set to {{SFrameTransformErrorEventType/syntax}}
        and its {{SFrameTransformErrorEvent/frame}} attribute set to |frame|.
     1. If the processing fails on decryption side due to the key identifier parsed in |data| being unknown, [=fire an event=] named {{SFrameTransform/onerror|error}} at |sframe|,
        using the {{SFrameTransformErrorEvent}} interface with its {{SFrameTransformErrorEvent/errorType}} attribute set to {{SFrameTransformErrorEventType/keyID}},
        its {{SFrameTransformErrorEvent/frame}} attribute set to |frame| and its {{SFrameTransformErrorEvent/keyID}} attribute set to the keyID value parsed in the SFrame header.
     1. If the processing fails on decryption side due to validation of the authentication tag, [=fire an event=] named {{SFrameTransform/onerror|error}} at |sframe|,
        using the {{SFrameTransformErrorEvent}} interface with its {{SFrameTransformErrorEvent/errorType}} attribute set to {{SFrameTransformErrorEventType/authentication}}
        and its {{SFrameTransformErrorEvent/frame}} attribute set to |frame|.
     1. Abort these steps.
1. If |frame| is a {{BufferSource}}, set |frame| to |buffer|.
1. If |frame| is a {{RTCEncodedAudioFrame}}, set |frame|.{{RTCEncodedAudioFrame/data}} to |buffer|.
1. If |frame| is a {{RTCEncodedVideoFrame}}, set |frame|.{{RTCEncodedVideoFrame/data}} to |buffer|.
1. [=ReadableStream/Enqueue=] |frame| in |sframe|.`[[transform]]`.

## Methods ## {#sframe-transform-methods}
The <dfn method for="SFrameTransform">setEncryptionKey(|key|, |keyID|)</dfn> method steps are:
1. Let |promise| be [=a new promise=].
2. If |keyID| is a {{bigint}} which cannot be represented as a integer between 0 and 2<sup>64</sup>-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, as defined by the <a href="https://datatracker.ietf.org/doc/draft-omara-sframe/">SFrame specification</a>.
    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|.


# RTCRtpScriptTransform # {#scriptTransform}

## <dfn>RTCEncodedVideoFrameType</dfn> dictionary ## {#RTCEncodedVideoFrameType}
<pre class="idl">
// New enum for video frame types. Will eventually re-use the equivalent defined
// by WebCodecs.
enum RTCEncodedVideoFrameType {
    "empty",
    "key",
    "delta",
};
</pre>
<table data-link-for="RTCEncodedVideoFrameType" data-dfn-for=
    "RTCEncodedVideoFrameType" class="simple">
    <caption>Enumeration description</caption>
    <thead>
        <tr>
            <th>Enum value</th><th>Description</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>
                <dfn data-idl="">empty</dfn>
            </td>
            <td>
                <p>
                    This frame contains no data.
                </p>
            </td>
        </tr>
        <tr>
            <td>
                <dfn data-idl="">key</dfn>
            </td>
            <td>
                <p>
                    This frame can be decoded without reference to any other frames.
                </p>
            </td>
        </tr>
        <tr>
            <td>
                <dfn data-idl="">delta</dfn>
            </td>
            <td>
                <p>
                    This frame references another frame and can not be decoded without that frame.
                </p>
            </td>
        </tr>
    </tbody>
</table>

## <dfn>RTCEncodedVideoFrameMetadata</dfn> dictionary ## {#RTCEncodedVideoFrameMetadata}
<pre class="idl">
dictionary RTCEncodedVideoFrameMetadata {
    long long frameId;
    sequence&lt;long long&gt; dependencies;
    unsigned short width;
    unsigned short height;
    long spatialIndex;
    long temporalIndex;
    unsigned long synchronizationSource;
    octet payloadType;
    sequence&lt;unsigned long&gt; contributingSources;
};
</pre>

### Members ### {#RTCEncodedVideoFrameMetadata-members}
<dl data-link-for="RTCEncodedVideoFrameMetadata"
        data-dfn-for="RTCEncodedVideoFrameMetadata"
        class="dictionary-members">
    <dt>
        <dfn>synchronizationSource</dfn> of type <span class="idlMemberType">unsigned long</span>
    </dt>
    <dd>
        <p>
            The synchronization source (ssrc) identifier is an unsigned integer value per [[RFC3550]]
            used to identify the stream of RTP packets that the encoded frame object is describing.
        </p>
    </dd>
    <dt>
        <dfn>payloadType</dfn> of type <span class="idlMemberType">octet</span>
    </dt>
    <dd>
        <p>
            The payload type is an unsigned integer value in the range from 0 to 127 per [[RFC3550]]
            that is used to describe the format of the RTP payload.
        </p>
    </dd>
    <dt>
        <dfn>contributingSources</dfn> of type <span class=
            "idlMemberType">sequence&lt;unsigned long&gt;</span>
    </dt>
    <dd>
        <p>
            The list of contribution sources (csrc list) as defined in [[RFC3550]].
        </p>
    </dd>
</dl>


## <dfn>RTCEncodedVideoFrame</dfn> interface ## {#RTCEncodedVideoFrame-interface}
<pre class="idl">
// 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 timestamp;
    attribute ArrayBuffer data;
    RTCEncodedVideoFrameMetadata getMetadata();
};
</pre>

### Members ### {#RTCEncodedVideoFrame-members}
<dl data-link-for="RTCEncodedVideoFrame"
        data-dfn-for="RTCEncodedVideoFrame"
        class="dictionary-members">
    <dt>
        <dfn>type</dfn> of type <span class="idlMemberType">RTCEncodedVideoFrameType</span>
    </dt>
    <dd>
        <p>
            The type attribute allows the application to determine when a key frame is being
            sent or received.
        </p>
    </dd>

    <dt>
        <dfn>timestamp</dfn> of type <span class="idlMemberType">unsigned long</span>
    </dt>
    <dd>
        <p>
            The RTP timestamp identifier is an unsigned integer value per [[RFC3550]]
            that reflects the sampling instant of the first octet in the RTP data packet.
        </p>
    </dd>
    <dt>
        <dfn>data</dfn> of type <span class="idlMemberType">ArrayBuffer</span>
    </dt>
    <dd>
        <p>
            The encoded frame data.
        </p>
    </dd>
</dl>

### Methods ### {#RTCEncodedVideoFrame-methods}
<dl data-link-for="RTCEncodedVideoFrame"
        data-dfn-for="RTCEncodedVideoFrame"
        class="dictionary-members">
    <dt>
        <dfn data-dfn-for="RTCEncodedVideoFrame" data-dfn-type="method">getMetadata()</dfn>
    </dt>
    <dd>
        <p>
            Returns the metadata associated with the frame.
        </p>
    </dd>
</dl>

## <dfn>RTCEncodedAudioFrameMetadata</dfn> dictionary ## {#RTCEncodedAudioFrameMetadata}
<pre class="idl">
dictionary RTCEncodedAudioFrameMetadata {
    unsigned long synchronizationSource;
    octet payloadType;
    sequence&lt;unsigned long&gt; contributingSources;
};
</pre>
### Members ### {#RTCEncodedAudioFrameMetadata-members}
<dl data-link-for="RTCEncodedAudioFrameMetadata"
        data-dfn-for="RTCEncodedAudioFrameMetadata"
        class="dictionary-members">
    <dt>
        <dfn>synchronizationSource</dfn> of type <span class="idlMemberType">unsigned long</span>
    </dt>
    <dd>
        <p>
            The synchronization source (ssrc) identifier is an unsigned integer value per [[RFC3550]]
            used to identify the stream of RTP packets that the encoded frame object is describing.
        </p>
    </dd>
    <dt>
        <dfn>payloadType</dfn> of type <span class="idlMemberType">octet</span>
    </dt>
    <dd>
        <p>
            The payload type is an unsigned integer value in the range from 0 to 127 per [[RFC3550]]
            that is used to describe the format of the RTP payload.
        </p>
    </dd>
    <dt>
        <dfn>contributingSources</dfn> of type <span class=
            "idlMemberType">sequence&lt;unsigned long&gt;</span>
    </dt>
    <dd>
        <p>
            The list of contribution sources (csrc list) as defined in [[RFC3550]].
        </p>
    </dd>
</dl>

## <dfn>RTCEncodedAudioFrame</dfn> interface ## {#RTCEncodedAudioFrame-interface}
<pre class="idl">
[Exposed=(Window,DedicatedWorker)]
interface RTCEncodedAudioFrame {
    readonly attribute unsigned long timestamp;
    attribute ArrayBuffer data;
    RTCEncodedAudioFrameMetadata getMetadata();
};
</pre>

### Members ### {#RTCEncodedAudioFrame-members}
<dl data-link-for="RTCEncodedAudioFrame"
        data-dfn-for="RTCEncodedAudioFrame"
        class="dictionary-members">
    <dt>
        <dfn>timestamp</dfn> of type <span class="idlMemberType">unsigned long</span>
    </dt>
    <dd>
        <p>
            The RTP timestamp identifier is an unsigned integer value per [[RFC3550]]
            that reflects the sampling instant of the first octet in the RTP data packet.
        </p>
    </dd>
    <dt>
        <dfn>data</dfn> of type <span class="idlMemberType">ArrayBuffer</span>
    </dt>
    <dd>
        <p>
            The encoded frame data.
        </p>
    </dd>
</dl>

### Methods ### {#RTCEncodedAudioFrame-methods}
<dl data-link-for="RTCEncodedAudioFrame"
        data-dfn-for="RTCEncodedAudioFrame"
        class="dictionary-members">
    <dt>
        <dfn data-dfn-for="RTCEncodedAudioFrame" data-dfn-type="method">getMetadata()</dfn>
    </dt>
    <dd>
        <p>
            Returns the metadata associated with the frame.
        </p>
    </dd>
</dl>


// New interfaces to expose JavaScript-based transforms.
##Interfaces
<pre class="idl">
[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;
    Promise&lt;undefined&gt; generateKeyFrame(optional sequence&lt;DOMString&gt; rids);
    Promise&lt;undefined&gt; sendKeyFrameRequest();
};

[Exposed=Window]
interface RTCRtpScriptTransform {
    constructor(Worker worker, optional any options, optional sequence&lt;object&gt; transfer);
};
</pre>

## Operations ## {#RTCRtpScriptTransform-operations}

The <dfn constructor for="RTCRtpScriptTransform" lt="RTCRtpScriptTransform(worker, options)"><code>new RTCRtpScriptTransform(|worker|, |options|, |transfer|)</code></dfn> constructor steps are:
1. Set |t1| to an [=identity transform stream=].
2. Set |t2| to an [=identity transform stream=].
3. Set |this|.`[[writable]]` to |t1|.`[[writable]]`.
4. Set |this|.`[[readable]]` to |t2|.`[[readable]]`.
5. Let |serializedOptions| be the result of [$StructuredSerializeWithTransfer$](|options|, |transfer|).
6. Let |serializedReadable| be the result of [$StructuredSerializeWithTransfer$](|t1|.`[[readable]]`, « |t1|.`[[readable]]` »).
7. Let |serializedWritable| be the result of [$StructuredSerializeWithTransfer$](|t2|.`[[writable]]`, « |t2|.`[[writable]]` »).
8. [=Queue a task=] on the DOM manipulation [=task source=] |worker|'s global scope to run the following steps:
    1. Let |transformerOptions| be the result of [$StructuredDeserialize$](|serializedOptions|, the current Realm).
    2. Let |readable| be the result of [$StructuredDeserialize$](|serializedReadable|, the current Realm).
    3. Let |writable| be the result of [$StructuredDeserialize$](|serializedWritable|, the current Realm).
    4. Let |transformer| be a new {{RTCRtpScriptTransformer}}.
    5. Set |transformer|.`[[options]]` to |transformerOptions|.
    6. Set |transformer|.`[[readable]]` to |readable|.
    7. Set |transformer|.`[[writable]]` to |writable|.
    8. [=Fire an event=] named <dfn event for="DedicatedWorkerGlobalScope">rtctransform</dfn> using {{RTCTransformEvent}} with {{RTCTransformEvent/transformer}} set to |transformer| on |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).

Each RTCRtpScriptTransform has the following set of [=association steps=], given |rtcObject|:
1. Let |transform| be the {{RTCRtpScriptTransform}} object that owns the [=association steps=].
1. Let |encoder| be |rtcObject|'s encoder if |rtcObject| is a {{RTCRtpSender}} or undefined otherwise.
1. Let |depacketizer| be |rtcObject|'s depacketizer if |rtcObject| is a {{RTCRtpReceiver}} or undefined otherwise.
1. [=Queue a task=] on the DOM manipulation [=task source=] |worker|'s global scope to run the following steps:
    1. Let |transformer| be the {{RTCRtpScriptTransformer}} object associated to |transform|.
    1. Set |transformer|.`[[encoder]]` to |encoder|.
    1. Set |transformer|.`[[depacketizer]]` to |depacketizer|.

The <dfn method for="RTCRtpScriptTransformer">generateKeyFrame(|rids|)</dfn> method steps are:
1. Let |promise| be a new promise.
1. [=In parallel=], run the [=generate key frame algorithm=] with |promise|, the {{RTCRtpSender}} associated with |this|.`[[encoder]]` and |rids|.
1. Return |promise|.

The <dfn method for="RTCRtpScriptTransformer">sendKeyFrameRequest()</dfn> method steps are:
1. Let |promise| be a new promise.
1. [=In parallel=], run the [=send request key frame algorithm=] with |promise| and |this|.`[[depacketizer]]`.
1. Return |promise|.

## Attributes ## {#RTCRtpScriptTransformer-attributes}

A {{RTCRtpScriptTransformer}} has the following private slots called `[[depacketizer]]`, `[[encoder]]`, `[[options]]`, `[[readable]]` and `[[writable]]`.
In addition, a {{RTCRtpScriptTransformer}} is always associated with its parent {{RTCRtpScriptTransform}} transform.
This allows algorithms to go from an {{RTCRtpScriptTransformer}} object to its {{RTCRtpScriptTransform}} parent and vice versa.

The <dfn attribute for="RTCRtpScriptTransformer">options</dfn> getter steps are:
1. Return [=this=].`[[options]]`.

The <dfn attribute for="RTCRtpScriptTransformer">readable</dfn> getter steps are:
1. Return [=this=].`[[readable]]`.

The <dfn attribute for="RTCRtpScriptTransformer">writable</dfn> getter steps are:
1. Return [=this=].`[[writable]]`.

## KeyFrame Algorithms ## {#KeyFrame-algorithms}

The <dfn>generate key frame algorithm</dfn>, given |promise|, |sender| and |rids|, is defined by running these steps:
1. If the sender's transceiver kind is not `video`, reject |promise| with an {{OperationError}} and abort these steps.
1. If |rids| is defined, for each |rid| in rids,
    1. if |rid| is not associated with |sender|, reject Promise with an {{InvalidAccessError}} and abort these steps.
1. Instruct the encoder associated with |sender| to generate a key frame for |rids| or all layers when |rids| is empty.
1. Resolve |promise| with `undefined`.

The <dfn>send request key frame algorithm</dfn>, given |promise| and |depacketizer|, is defined by running these steps:
1. If |depacketizer| is undefined, reject |promise| with {{InvalidStateError}}, abort these steps.
1. If |depacketizer| is not processing video packets, reject |promise| with {{InvalidStateError}}, abort these steps.
1. [=In parallel=], run the following steps:
    1. If sending a Full Intra Request (FIR) by |depacketizer|'s receiver is not deemed appropriate, [=resolve=] |promise| with undefined and abort these steps.
        Section 4.3.1 of [[RFC5104]] provides guidelines of how and when it is appropriate to sending a Full Intra Request.
    1. Generate a Full Intra Request (FIR) packet as defined in section 4.3.1 of [[RFC5104]] and send it through |depacketizer|'s receiver.
    1. [=Resolve=] |promise| with undefined.

# RTCRtpSender extension # {#rtcrtpsender-extension}

An additional API on {{RTCRtpSender}} is added to complement the generation of key frame added to {{RTCRtpScriptTransformer}}.

<pre class="idl">
partial interface RTCRtpSender {
    Promise&lt;undefined&gt; generateKeyFrame(optional sequence&lt;DOMString&gt; rids);
};
</pre>

## Extension operation ## {#sender-operation}

The <dfn method for="RTCRtpSender">generateKeyFrame(|rids|)</dfn> method steps are:

1. Let |promise| be a new promise.
1. [=In parallel=], run the [=generate key frame algorithm=] with |promise|, |this| and |rids|.
1. Return |promise|.

# Privacy and security considerations # {#privacy}

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.

# Examples # {#examples}

See the [explainer document](https://github.com/w3c/webrtc-encoded-transform/blob/master/explainer.md#code-examples).