1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into webref
// (https://github.com/w3c/webref)
// Source: WebRTC Encoded Transform (https://w3c.github.io/webrtc-encoded-transform/)
typedef (SFrameSenderTransform or RTCRtpScriptTransform) RTCRtpSenderTransform;
typedef (SFrameReceiverTransform or RTCRtpScriptTransform) RTCRtpReceiverTransform;
// New methods for RTCRtpSender and RTCRtpReceiver
partial interface RTCRtpSender {
attribute RTCRtpSenderTransform? transform;
};
partial interface RTCRtpReceiver {
attribute RTCRtpReceiverTransform? transform;
};
// List of supported cipher suites, as defined in [[RFC9605]] section 4.5.
enum SFrameCipherSuite {
"AES_128_CTR_HMAC_SHA256_80",
"AES_128_CTR_HMAC_SHA256_64",
"AES_128_CTR_HMAC_SHA256_32",
"AES_128_GCM_SHA256_128",
"AES_256_GCM_SHA512_128"
};
dictionary SFrameTransformOptions {
required SFrameCipherSuite cipherSuite;
};
typedef [EnforceRange] unsigned long long SmallCryptoKeyID;
typedef (SmallCryptoKeyID or bigint) CryptoKeyID;
interface mixin SFrameEncrypterManager {
Promise<undefined> setEncryptionKey(CryptoKey key, CryptoKeyID keyId);
};
interface mixin SFrameDecrypterManager {
Promise<undefined> addDecryptionKey(CryptoKey key, CryptoKeyID keyId);
Promise<undefined> removeDecryptionKey(CryptoKeyID keyId);
attribute EventHandler onerror;
};
[Exposed=Window]
interface SFrameSenderTransform {
constructor(optional SFrameTransformOptions options = {});
};
SFrameSenderTransform includes SFrameEncrypterManager;
[Exposed=Window]
interface SFrameReceiverTransform : EventTarget {
constructor(optional SFrameTransformOptions options = {});
};
SFrameReceiverTransform includes SFrameDecrypterManager;
[Exposed=(Window,DedicatedWorker)]
interface SFrameEncrypterStream : EventTarget {
constructor(optional SFrameTransformOptions options = {});
};
SFrameEncrypterStream includes GenericTransformStream;
SFrameEncrypterStream includes SFrameEncrypterManager;
[Exposed=(Window,DedicatedWorker)]
interface SFrameDecrypterStream : EventTarget {
constructor(optional SFrameTransformOptions options = {});
};
SFrameDecrypterStream includes GenericTransformStream;
SFrameDecrypterStream includes SFrameDecrypterManager;
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;
};
dictionary RTCEncodedFrameMetadata {
unsigned long synchronizationSource;
octet payloadType;
sequence<unsigned long> contributingSources;
unsigned long rtpTimestamp;
DOMHighResTimeStamp receiveTime;
DOMHighResTimeStamp captureTime;
DOMHighResTimeStamp senderCaptureTimeOffset;
DOMString mimeType;
};
dictionary RTCEncodedVideoFrameMetadata : RTCEncodedFrameMetadata {
unsigned long long frameId;
sequence<unsigned long long> dependencies;
unsigned short width;
unsigned short height;
unsigned long spatialIndex;
unsigned long temporalIndex;
long long timestamp; // microseconds
};
dictionary RTCEncodedVideoFrameOptions {
RTCEncodedVideoFrameMetadata metadata;
};
// New interfaces to define RTC specific encoded video and audio frames used by RTCRtpScriptTransform.
[Exposed=(Window,DedicatedWorker), Serializable]
interface RTCEncodedVideoFrame {
constructor(RTCEncodedVideoFrame originalFrame, optional RTCEncodedVideoFrameOptions options = {});
readonly attribute EncodedVideoChunkType type;
attribute ArrayBuffer data;
RTCEncodedVideoFrameMetadata getMetadata();
};
dictionary RTCEncodedAudioFrameMetadata : RTCEncodedFrameMetadata {
short sequenceNumber;
double audioLevel;
};
dictionary RTCEncodedAudioFrameOptions {
RTCEncodedAudioFrameMetadata metadata;
};
[Exposed=(Window,DedicatedWorker), Serializable]
interface RTCEncodedAudioFrame {
constructor(RTCEncodedAudioFrame originalFrame, optional RTCEncodedAudioFrameOptions options = {});
attribute ArrayBuffer data;
RTCEncodedAudioFrameMetadata getMetadata();
};
[Exposed=Window]
interface RTCRtpScriptTransform {
constructor(Worker worker, optional any options, optional sequence<object> transfer);
};
[Exposed=DedicatedWorker]
interface RTCRtpScriptTransformer : EventTarget {
// Attributes and methods related to the transformer source
readonly attribute ReadableStream readable;
Promise<undefined> generateKeyFrame(optional DOMString rid);
Promise<undefined> sendKeyFrameRequest();
// Attributes and methods related to the transformer sink
readonly attribute WritableStream writable;
attribute EventHandler onkeyframerequest;
// Attributes for configuring the Javascript code
readonly attribute any options;
};
[Exposed=DedicatedWorker]
interface RTCTransformEvent : Event {
readonly attribute RTCRtpScriptTransformer transformer;
};
partial interface DedicatedWorkerGlobalScope {
attribute EventHandler onrtctransform;
};
[Exposed=DedicatedWorker]
interface KeyFrameRequestEvent : Event {
constructor(DOMString type, optional DOMString rid);
readonly attribute DOMString? rid;
};
|
