rob
/
moq-rs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Using spaces is WAY better for your career. 

This is because in JavaScript, there is a HEAVY perception bias against tab users.

Most ES6 developers look down on anyone who uses tabs.
This could easily mean the difference between getting a job offer and being rejected.
It could mean tens of thousands of dollars of salary potential.

https://medium.com/mintbean-io/tabs-or-spaces-for-practical-javascript-developers-the-answer-is-clear-f66c0458aa1e
This commit is contained in:
Luke Curley 2023-05-22 21:49:02 -07:00
parent cc8792da09
commit 7843f8b0e4
29 changed files with 1366 additions and 1387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
web/.eslintrc.cjs
View File

@ -1,26 +1,26 @@
/* eslint-env node */ /* eslint-env node */
module.exports = { module.exports = {
extends: [ extends: [
"eslint:recommended", "eslint:recommended",
"plugin:@typescript-eslint/recommended", "plugin:@typescript-eslint/recommended",
"prettier", "prettier",
], ],
parser: "@typescript-eslint/parser", parser: "@typescript-eslint/parser",
plugins: ["@typescript-eslint"], plugins: ["@typescript-eslint"],
root: true, root: true,
ignorePatterns: ["dist", "node_modules"], ignorePatterns: ["dist", "node_modules"],
rules: { rules: {
"@typescript-eslint/ban-ts-comment": "off", "@typescript-eslint/ban-ts-comment": "off",
"@typescript-eslint/no-non-null-assertion": "off", "@typescript-eslint/no-non-null-assertion": "off",
"@typescript-eslint/no-explicit-any": "off", "@typescript-eslint/no-explicit-any": "off",
"no-unused-vars": "off", // note you must disable the base rule as it can report incorrect errors "no-unused-vars": "off", // note you must disable the base rule as it can report incorrect errors
"@typescript-eslint/no-unused-vars": [ "@typescript-eslint/no-unused-vars": [
"warn", // or "error" "warn", // or "error"
{ {
argsIgnorePattern: "^_", argsIgnorePattern: "^_",
varsIgnorePattern: "^_", varsIgnorePattern: "^_",
caughtErrorsIgnorePattern: "^_", caughtErrorsIgnorePattern: "^_",
}, },
], ],
}, },
} }

4
web/.prettierrc.json
View File

@ -1,5 +1,3 @@
{ {
"useTabs": true, "semi": false
"tabWidth": 4,
"semi": false
} }

10
web/.proxyrc.js
View File

@ -1,7 +1,7 @@
module.exports = function (app) { module.exports = function (app) {
app.use((req, res, next) => { app.use((req, res, next) => {
res.setHeader("Cross-Origin-Opener-Policy", "same-origin") res.setHeader("Cross-Origin-Opener-Policy", "same-origin")
res.setHeader("Cross-Origin-Embedder-Policy", "require-corp") res.setHeader("Cross-Origin-Embedder-Policy", "require-corp")
next() next()
}) })
} }

50
web/package.json
View File

@ -1,27 +1,27 @@
{ {
"license": "Apache-2.0", "license": "Apache-2.0",
"source": "src/index.html", "source": "src/index.html",
"scripts": { "scripts": {
"serve": "parcel serve --https --cert ../cert/localhost.crt --key ../cert/localhost.key --port 4444 --open", "serve": "parcel serve --https --cert ../cert/localhost.crt --key ../cert/localhost.key --port 4444 --open",
"build": "parcel build", "build": "parcel build",
"check": "tsc --noEmit", "check": "tsc --noEmit",
"lint": "eslint .", "lint": "eslint .",
"fmt": "prettier --write ." "fmt": "prettier --write ."
}, },
"devDependencies": { "devDependencies": {
"@parcel/transformer-inline-string": "2.8.3", "@parcel/transformer-inline-string": "2.8.3",
"@parcel/validator-typescript": "^2.6.0", "@parcel/validator-typescript": "^2.6.0",
"@types/audioworklet": "^0.0.41", "@types/audioworklet": "^0.0.41",
"@types/dom-webcodecs": "^0.1.6", "@types/dom-webcodecs": "^0.1.6",
"@typescript-eslint/eslint-plugin": "^5.59.7", "@typescript-eslint/eslint-plugin": "^5.59.7",
"@typescript-eslint/parser": "^5.59.7", "@typescript-eslint/parser": "^5.59.7",
"eslint": "^8.41.0", "eslint": "^8.41.0",
"eslint-config-prettier": "^8.8.0", "eslint-config-prettier": "^8.8.0",
"parcel": "^2.8.0", "parcel": "^2.8.0",
"prettier": "^2.8.8", "prettier": "^2.8.8",
"typescript": "^5.0.4" "typescript": "^5.0.4"
}, },
"dependencies": { "dependencies": {
"mp4box": "^0.5.2" "mp4box": "^0.5.2"
} }
} }

158
web/src/broadcaster/encoder.ts
View File

@ -1,104 +1,104 @@
import * as MP4 from "../mp4" import * as MP4 from "../mp4"
export class Encoder { export class Encoder {
container: MP4.ISOFile container: MP4.ISOFile
audio: AudioEncoder audio: AudioEncoder
video: VideoEncoder video: VideoEncoder
constructor() { constructor() {
this.container = new MP4.ISOFile() this.container = new MP4.ISOFile()
this.audio = new AudioEncoder({ this.audio = new AudioEncoder({
output: this.onAudio.bind(this), output: this.onAudio.bind(this),
error: console.warn, error: console.warn,
}) })
this.video = new VideoEncoder({ this.video = new VideoEncoder({
output: this.onVideo.bind(this), output: this.onVideo.bind(this),
error: console.warn, error: console.warn,
}) })
this.container.init() this.container.init()
this.audio.configure({ this.audio.configure({
codec: "mp4a.40.2", codec: "mp4a.40.2",
numberOfChannels: 2, numberOfChannels: 2,
sampleRate: 44100, sampleRate: 44100,
// TODO bitrate // TODO bitrate
}) })
this.video.configure({ this.video.configure({
codec: "avc1.42002A", // TODO h.264 baseline codec: "avc1.42002A", // TODO h.264 baseline
avc: { format: "avc" }, // or annexb avc: { format: "avc" }, // or annexb
width: 1280, width: 1280,
height: 720, height: 720,
// TODO bitrate // TODO bitrate
// TODO bitrateMode // TODO bitrateMode
// TODO framerate // TODO framerate
// TODO latencyMode // TODO latencyMode
}) })
} }
onAudio(frame: EncodedAudioChunk, metadata: EncodedAudioChunkMetadata) { onAudio(frame: EncodedAudioChunk, metadata: EncodedAudioChunkMetadata) {
const config = metadata.decoderConfig! const config = metadata.decoderConfig!
const track_id = 1 const track_id = 1
if (!this.container.getTrackById(track_id)) { if (!this.container.getTrackById(track_id)) {
this.container.addTrack({ this.container.addTrack({
id: track_id, id: track_id,
type: "mp4a", // TODO wrong type: "mp4a", // TODO wrong
timescale: 1000, // TODO verify timescale: 1000, // TODO verify
channel_count: config.numberOfChannels, channel_count: config.numberOfChannels,
samplerate: config.sampleRate, samplerate: config.sampleRate,
description: config.description, // TODO verify description: config.description, // TODO verify
// TODO description_boxes?: Box[]; // TODO description_boxes?: Box[];
}) })
} }
const buffer = new Uint8Array(frame.byteLength) const buffer = new Uint8Array(frame.byteLength)
frame.copyTo(buffer) frame.copyTo(buffer)
// TODO cts? // TODO cts?
const sample = this.container.addSample(track_id, buffer, { const sample = this.container.addSample(track_id, buffer, {
is_sync: frame.type == "key", is_sync: frame.type == "key",
duration: frame.duration!, duration: frame.duration!,
dts: frame.timestamp, dts: frame.timestamp,
}) })
const _stream = this.container.createSingleSampleMoof(sample) const _stream = this.container.createSingleSampleMoof(sample)
} }
onVideo(frame: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata) { onVideo(frame: EncodedVideoChunk, metadata?: EncodedVideoChunkMetadata) {
const config = metadata!.decoderConfig! const config = metadata!.decoderConfig!
const track_id = 2 const track_id = 2
if (!this.container.getTrackById(track_id)) { if (!this.container.getTrackById(track_id)) {
this.container.addTrack({ this.container.addTrack({
id: 2, id: 2,
type: "avc1", type: "avc1",
width: config.codedWidth, width: config.codedWidth,
height: config.codedHeight, height: config.codedHeight,
timescale: 1000, // TODO verify timescale: 1000, // TODO verify
description: config.description, // TODO verify description: config.description, // TODO verify
// TODO description_boxes?: Box[]; // TODO description_boxes?: Box[];
}) })
} }
const buffer = new Uint8Array(frame.byteLength) const buffer = new Uint8Array(frame.byteLength)
frame.copyTo(buffer) frame.copyTo(buffer)
// TODO cts? // TODO cts?
const sample = this.container.addSample(track_id, buffer, { const sample = this.container.addSample(track_id, buffer, {
is_sync: frame.type == "key", is_sync: frame.type == "key",
duration: frame.duration!, duration: frame.duration!,
dts: frame.timestamp, dts: frame.timestamp,
}) })
const _stream = this.container.createSingleSampleMoof(sample) const _stream = this.container.createSingleSampleMoof(sample)
} }
} }

6
web/src/broadcaster/index.ts
View File

@ -1,5 +1,5 @@
export default class Broadcaster { export default class Broadcaster {
constructor() { constructor() {
// TODO // TODO
} }
} }

72
web/src/index.css
View File

@ -1,75 +1,75 @@
html, html,
body, body,
#player { #player {
width: 100%; width: 100%;
} }
body { body {
background: #000000; background: #000000;
color: #ffffff; color: #ffffff;
padding: 0; padding: 0;
margin: 0; margin: 0;
display: flex; display: flex;
justify-content: center; justify-content: center;
font-family: sans-serif; font-family: sans-serif;
} }
#screen { #screen {
position: relative; position: relative;
} }
#screen #play { #screen #play {
position: absolute; position: absolute;
width: 100%; width: 100%;
height: 100%; height: 100%;
background: rgba(0, 0, 0, 0.5); background: rgba(0, 0, 0, 0.5);
display: flex; display: flex;
justify-content: center; justify-content: center;
align-items: center; align-items: center;
z-index: 1; z-index: 1;
} }
#controls { #controls {
display: flex; display: flex;
flex-wrap: wrap; flex-wrap: wrap;
padding: 8px 16px; padding: 8px 16px;
} }
#controls > * { #controls > * {
margin-right: 8px; margin-right: 8px;
} }
#controls label { #controls label {
margin-right: 8px; margin-right: 8px;
} }
#stats { #stats {
display: grid; display: grid;
grid-template-columns: auto 1fr; grid-template-columns: auto 1fr;
} }
#stats label { #stats label {
padding: 0 1rem; padding: 0 1rem;
} }
.buffer { .buffer {
position: relative; position: relative;
width: 100%; width: 100%;
} }
.buffer .fill { .buffer .fill {
position: absolute; position: absolute;
transition-duration: 0.1s; transition-duration: 0.1s;
transition-property: left, right, background-color; transition-property: left, right, background-color;
background-color: RebeccaPurple; background-color: RebeccaPurple;
height: 100%; height: 100%;
text-align: right; text-align: right;
padding-right: 0.5rem; padding-right: 0.5rem;
overflow: hidden; overflow: hidden;
} }
.buffer .fill.net { .buffer .fill.net {
background-color: Purple; background-color: Purple;
} }

48
web/src/index.html
View File

@ -1,33 +1,33 @@
<!DOCTYPE html> <!DOCTYPE html>
<html> <html>
<head> <head>
<meta charset="UTF-8" /> <meta charset="UTF-8" />
<title>WARP</title> <title>WARP</title>
<link rel="stylesheet" href="index.css" /> <link rel="stylesheet" href="index.css" />
</head> </head>
<body> <body>
<div id="player"> <div id="player">
<div id="screen"> <div id="screen">
<div id="play"><span>click to play</span></div> <div id="play"><span>click to play</span></div>
<canvas id="video" width="1280" height="720"></canvas> <canvas id="video" width="1280" height="720"></canvas>
</div> </div>
<div id="controls"> <div id="controls">
<button type="button" id="live">Go Live</button> <button type="button" id="live">Go Live</button>
<button type="button" id="throttle">Throttle: None</button> <button type="button" id="throttle">Throttle: None</button>
</div> </div>
<div id="stats"> <div id="stats">
<label>Audio Buffer:</label> <label>Audio Buffer:</label>
<div class="audio buffer"></div> <div class="audio buffer"></div>
<label>Video Buffer:</label> <label>Video Buffer:</label>
<div class="video buffer"></div> <div class="video buffer"></div>
</div> </div>
</div> </div>
<script src="index.ts" type="module"></script> <script src="index.ts" type="module"></script>
</body> </body>
</html> </html>

26
web/src/index.ts
View File

@ -7,7 +7,7 @@ import fingerprintHex from "bundle-text:../fingerprint.hex"
// Convert the hex to binary. // Convert the hex to binary.
const fingerprint = [] const fingerprint = []
for (let c = 0; c < fingerprintHex.length - 1; c += 2) { for (let c = 0; c < fingerprintHex.length - 1; c += 2) {
fingerprint.push(parseInt(fingerprintHex.substring(c, c + 2), 16)) fingerprint.push(parseInt(fingerprintHex.substring(c, c + 2), 16))
} }
const params = new URLSearchParams(window.location.search) const params = new URLSearchParams(window.location.search)
@ -16,27 +16,27 @@ const url = params.get("url") || "https://localhost:4443/watch"
const canvas = document.querySelector<HTMLCanvasElement>("canvas#video")! const canvas = document.querySelector<HTMLCanvasElement>("canvas#video")!
const transport = new Transport({ const transport = new Transport({
url: url, url: url,
fingerprint: { fingerprint: {
// TODO remove when Chrome accepts the system CA // TODO remove when Chrome accepts the system CA
algorithm: "sha-256", algorithm: "sha-256",
value: new Uint8Array(fingerprint), value: new Uint8Array(fingerprint),
}, },
}) })
const player = new Player({ const player = new Player({
transport, transport,
canvas: canvas.transferControlToOffscreen(), canvas: canvas.transferControlToOffscreen(),
}) })
const play = document.querySelector<HTMLElement>("#screen #play")! const play = document.querySelector<HTMLElement>("#screen #play")!
const playFunc = (e: Event) => { const playFunc = (e: Event) => {
player.play() player.play()
e.preventDefault() e.preventDefault()
play.removeEventListener("click", playFunc) play.removeEventListener("click", playFunc)
play.style.display = "none" play.style.display = "none"
} }
play.addEventListener("click", playFunc) play.addEventListener("click", playFunc)

22
web/src/mp4/index.ts
View File

@ -1,16 +1,16 @@
// Rename some stuff so it's on brand. // Rename some stuff so it's on brand.
export { export {
createFile as New, createFile as New,
MP4File as File, MP4File as File,
MP4ArrayBuffer as ArrayBuffer, MP4ArrayBuffer as ArrayBuffer,
MP4Info as Info, MP4Info as Info,
MP4Track as Track, MP4Track as Track,
MP4AudioTrack as AudioTrack, MP4AudioTrack as AudioTrack,
MP4VideoTrack as VideoTrack, MP4VideoTrack as VideoTrack,
DataStream as Stream, DataStream as Stream,
Box, Box,
ISOFile, ISOFile,
Sample, Sample,
} from "mp4box" } from "mp4box"
export { Init, InitParser } from "./init" export { Init, InitParser } from "./init"

58
web/src/mp4/init.ts
View File

@ -1,43 +1,43 @@
import * as MP4 from "./index" import * as MP4 from "./index"
export interface Init { export interface Init {
raw: MP4.ArrayBuffer raw: MP4.ArrayBuffer
info: MP4.Info info: MP4.Info
} }
export class InitParser { export class InitParser {
mp4box: MP4.File mp4box: MP4.File
offset: number offset: number
raw: MP4.ArrayBuffer[] raw: MP4.ArrayBuffer[]
info: Promise<MP4.Info> info: Promise<MP4.Info>
constructor() { constructor() {
this.mp4box = MP4.New() this.mp4box = MP4.New()
this.raw = [] this.raw = []
this.offset = 0 this.offset = 0
// Create a promise that gets resolved once the init segment has been parsed. // Create a promise that gets resolved once the init segment has been parsed.
this.info = new Promise((resolve, reject) => { this.info = new Promise((resolve, reject) => {
this.mp4box.onError = reject this.mp4box.onError = reject
this.mp4box.onReady = resolve this.mp4box.onReady = resolve
}) })
} }
push(data: Uint8Array) { push(data: Uint8Array) {
// Make a copy of the atom because mp4box only accepts an ArrayBuffer unfortunately // Make a copy of the atom because mp4box only accepts an ArrayBuffer unfortunately
const box = new Uint8Array(data.byteLength) const box = new Uint8Array(data.byteLength)
box.set(data) box.set(data)
// and for some reason we need to modify the underlying ArrayBuffer with fileStart // and for some reason we need to modify the underlying ArrayBuffer with fileStart
const buffer = box.buffer as MP4.ArrayBuffer const buffer = box.buffer as MP4.ArrayBuffer
buffer.fileStart = this.offset buffer.fileStart = this.offset
// Parse the data // Parse the data
this.offset = this.mp4box.appendBuffer(buffer) this.offset = this.mp4box.appendBuffer(buffer)
this.mp4box.flush() this.mp4box.flush()
// Add the box to our queue of chunks // Add the box to our queue of chunks
this.raw.push(buffer) this.raw.push(buffer)
} }
} }

402
web/src/mp4/mp4box.d.ts vendored
View File

@ -1,243 +1,239 @@
// https://github.com/gpac/mp4box.js/issues/233 // https://github.com/gpac/mp4box.js/issues/233
declare module "mp4box" { declare module "mp4box" {
export interface MP4MediaTrack { export interface MP4MediaTrack {
id: number id: number
created: Date created: Date
modified: Date modified: Date
movie_duration: number movie_duration: number
layer: number layer: number
alternate_group: number alternate_group: number
volume: number volume: number
track_width: number track_width: number
track_height: number track_height: number
timescale: number timescale: number
duration: number duration: number
bitrate: number bitrate: number
codec: string codec: string
language: string language: string
nb_samples: number nb_samples: number
} }
export interface MP4VideoData { export interface MP4VideoData {
width: number width: number
height: number height: number
} }
export interface MP4VideoTrack extends MP4MediaTrack { export interface MP4VideoTrack extends MP4MediaTrack {
video: MP4VideoData video: MP4VideoData
} }
export interface MP4AudioData { export interface MP4AudioData {
sample_rate: number sample_rate: number
channel_count: number channel_count: number
sample_size: number sample_size: number
} }
export interface MP4AudioTrack extends MP4MediaTrack { export interface MP4AudioTrack extends MP4MediaTrack {
audio: MP4AudioData audio: MP4AudioData
} }
export type MP4Track = MP4VideoTrack | MP4AudioTrack export type MP4Track = MP4VideoTrack | MP4AudioTrack
export interface MP4Info { export interface MP4Info {
duration: number duration: number
timescale: number timescale: number
fragment_duration: number fragment_duration: number
isFragmented: boolean isFragmented: boolean
isProgressive: boolean isProgressive: boolean
hasIOD: boolean hasIOD: boolean
brands: string[] brands: string[]
created: Date created: Date
modified: Date modified: Date
tracks: MP4Track[] tracks: MP4Track[]
mime: string mime: string
audioTracks: MP4AudioTrack[] audioTracks: MP4AudioTrack[]
videoTracks: MP4VideoTrack[] videoTracks: MP4VideoTrack[]
} }
export type MP4ArrayBuffer = ArrayBuffer & { fileStart: number } export type MP4ArrayBuffer = ArrayBuffer & { fileStart: number }
export interface MP4File { export interface MP4File {
onMoovStart?: () => void onMoovStart?: () => void
onReady?: (info: MP4Info) => void onReady?: (info: MP4Info) => void
onError?: (e: string) => void onError?: (e: string) => void
onSamples?: (id: number, user: any, samples: Sample[]) => void onSamples?: (id: number, user: any, samples: Sample[]) => void
appendBuffer(data: MP4ArrayBuffer): number appendBuffer(data: MP4ArrayBuffer): number
start(): void start(): void
stop(): void stop(): void
flush(): void flush(): void
setExtractionOptions( setExtractionOptions(
id: number, id: number,
user: any, user: any,
options: ExtractionOptions options: ExtractionOptions
): void ): void
} }
export function createFile(): MP4File export function createFile(): MP4File
export interface Sample { export interface Sample {
number: number number: number
track_id: number track_id: number
timescale: number timescale: number
description_index: number description_index: number
description: any description: any
data: ArrayBuffer data: ArrayBuffer
size: number size: number
alreadyRead?: number alreadyRead?: number
duration: number duration: number
cts: number cts: number
dts: number dts: number
is_sync: boolean is_sync: boolean
is_leading: number is_leading: number
depends_on: number depends_on: number
is_depended_on: number is_depended_on: number
has_redundancy: number has_redundancy: number
degration_priority: number degration_priority: number
offset: number offset: number
subsamples: any subsamples: any
} }
export interface ExtractionOptions { export interface ExtractionOptions {
nbSamples: number nbSamples: number
} }
const BIG_ENDIAN: boolean const BIG_ENDIAN: boolean
const LITTLE_ENDIAN: boolean const LITTLE_ENDIAN: boolean
export class DataStream { export class DataStream {
constructor( constructor(
buffer?: ArrayBuffer, buffer?: ArrayBuffer,
byteOffset?: number, byteOffset?: number,
littleEndian?: boolean littleEndian?: boolean
) )
getPosition(): number getPosition(): number
get byteLength(): number get byteLength(): number
get buffer(): ArrayBuffer get buffer(): ArrayBuffer
set buffer(v: ArrayBuffer) set buffer(v: ArrayBuffer)
get byteOffset(): number get byteOffset(): number
set byteOffset(v: number) set byteOffset(v: number)
get dataView(): DataView get dataView(): DataView
set dataView(v: DataView) set dataView(v: DataView)
seek(pos: number): void seek(pos: number): void
isEof(): boolean isEof(): boolean
mapUint8Array(length: number): Uint8Array mapUint8Array(length: number): Uint8Array
readInt32Array(length: number, littleEndian: boolean): Int32Array readInt32Array(length: number, littleEndian: boolean): Int32Array
readInt16Array(length: number, littleEndian: boolean): Int16Array readInt16Array(length: number, littleEndian: boolean): Int16Array
readInt8Array(length: number): Int8Array readInt8Array(length: number): Int8Array
readUint32Array(length: number, littleEndian: boolean): Uint32Array readUint32Array(length: number, littleEndian: boolean): Uint32Array
readUint16Array(length: number, littleEndian: boolean): Uint16Array readUint16Array(length: number, littleEndian: boolean): Uint16Array
readUint8Array(length: number): Uint8Array readUint8Array(length: number): Uint8Array
readFloat64Array(length: number, littleEndian: boolean): Float64Array readFloat64Array(length: number, littleEndian: boolean): Float64Array
readFloat32Array(length: number, littleEndian: boolean): Float32Array readFloat32Array(length: number, littleEndian: boolean): Float32Array
readInt32(littleEndian: boolean): number readInt32(littleEndian: boolean): number
readInt16(littleEndian: boolean): number readInt16(littleEndian: boolean): number
readInt8(): number readInt8(): number
readUint32(littleEndian: boolean): number readUint32(littleEndian: boolean): number
readUint16(littleEndian: boolean): number readUint16(littleEndian: boolean): number
readUint8(): number readUint8(): number
readFloat32(littleEndian: boolean): number readFloat32(littleEndian: boolean): number
readFloat64(littleEndian: boolean): number readFloat64(littleEndian: boolean): number
endianness: boolean endianness: boolean
memcpy( memcpy(
dst: ArrayBufferLike, dst: ArrayBufferLike,
dstOffset: number, dstOffset: number,
src: ArrayBufferLike, src: ArrayBufferLike,
srcOffset: number, srcOffset: number,
byteLength: number byteLength: number
): void ): void
// TODO I got bored porting the remaining functions // TODO I got bored porting the remaining functions
} }
export class Box { export class Box {
write(stream: DataStream): void write(stream: DataStream): void
} }
export interface TrackOptions { export interface TrackOptions {
id?: number id?: number
type?: string type?: string
width?: number width?: number
height?: number height?: number
duration?: number duration?: number
layer?: number layer?: number
timescale?: number timescale?: number
media_duration?: number media_duration?: number
language?: string language?: string
hdlr?: string hdlr?: string
// video // video
avcDecoderConfigRecord?: any avcDecoderConfigRecord?: any
// audio // audio
balance?: number balance?: number
channel_count?: number channel_count?: number
samplesize?: number samplesize?: number
samplerate?: number samplerate?: number
//captions //captions
namespace?: string namespace?: string
schema_location?: string schema_location?: string
auxiliary_mime_types?: string auxiliary_mime_types?: string
description?: any description?: any
description_boxes?: Box[] description_boxes?: Box[]
default_sample_description_index_id?: number default_sample_description_index_id?: number
default_sample_duration?: number default_sample_duration?: number
default_sample_size?: number default_sample_size?: number
default_sample_flags?: number default_sample_flags?: number
} }
export interface FileOptions { export interface FileOptions {
brands?: string[] brands?: string[]
timescale?: number timescale?: number
rate?: number rate?: number
duration?: number duration?: number
width?: number width?: number
} }
export interface SampleOptions { export interface SampleOptions {
sample_description_index?: number sample_description_index?: number
duration?: number duration?: number
cts?: number cts?: number
dts?: number dts?: number
is_sync?: boolean is_sync?: boolean
is_leading?: number is_leading?: number
depends_on?: number depends_on?: number
is_depended_on?: number is_depended_on?: number
has_redundancy?: number has_redundancy?: number
degradation_priority?: number degradation_priority?: number
subsamples?: any subsamples?: any
} }
// TODO add the remaining functions // TODO add the remaining functions
// TODO move to another module // TODO move to another module
export class ISOFile { export class ISOFile {
constructor(stream?: DataStream) constructor(stream?: DataStream)
init(options?: FileOptions): ISOFile init(options?: FileOptions): ISOFile
addTrack(options?: TrackOptions): number addTrack(options?: TrackOptions): number
addSample( addSample(track: number, data: ArrayBuffer, options?: SampleOptions): Sample
track: number,
data: ArrayBuffer,
options?: SampleOptions
): Sample
createSingleSampleMoof(sample: Sample): Box createSingleSampleMoof(sample: Sample): Box
// helpers // helpers
getTrackById(id: number): Box | undefined getTrackById(id: number): Box | undefined
getTrexById(id: number): Box | undefined getTrexById(id: number): Box | undefined
} }
export {} export {}
} }

124
web/src/player/audio.ts
View File

@ -2,81 +2,81 @@ import * as Message from "./message"
import { Ring } from "./ring" import { Ring } from "./ring"
export default class Audio { export default class Audio {
ring?: Ring ring?: Ring
queue: Array<AudioData> queue: Array<AudioData>
render?: number // non-zero if requestAnimationFrame has been called render?: number // non-zero if requestAnimationFrame has been called
last?: number // the timestamp of the last rendered frame, in microseconds last?: number // the timestamp of the last rendered frame, in microseconds
constructor(_config: Message.Config) { constructor(_config: Message.Config) {
this.queue = [] this.queue = []
} }
push(frame: AudioData) { push(frame: AudioData) {
// Drop any old frames // Drop any old frames
if (this.last && frame.timestamp <= this.last) { if (this.last && frame.timestamp <= this.last) {
frame.close() frame.close()
return return
} }
// Insert the frame into the queue sorted by timestamp. // Insert the frame into the queue sorted by timestamp.
if ( if (
this.queue.length > 0 && this.queue.length > 0 &&
this.queue[this.queue.length - 1].timestamp <= frame.timestamp this.queue[this.queue.length - 1].timestamp <= frame.timestamp
) { ) {
// Fast path because we normally append to the end. // Fast path because we normally append to the end.
this.queue.push(frame) this.queue.push(frame)
} else { } else {
// Do a full binary search // Do a full binary search
let low = 0 let low = 0
let high = this.queue.length let high = this.queue.length
while (low < high) { while (low < high) {
const mid = (low + high) >>> 1 const mid = (low + high) >>> 1
if (this.queue[mid].timestamp < frame.timestamp) low = mid + 1 if (this.queue[mid].timestamp < frame.timestamp) low = mid + 1
else high = mid else high = mid
} }
this.queue.splice(low, 0, frame) this.queue.splice(low, 0, frame)
} }
this.emit() this.emit()
} }
emit() { emit() {
const ring = this.ring const ring = this.ring
if (!ring) { if (!ring) {
return return
} }
while (this.queue.length) { while (this.queue.length) {
const frame = this.queue[0] const frame = this.queue[0]
if (ring.size() + frame.numberOfFrames > ring.capacity) { if (ring.size() + frame.numberOfFrames > ring.capacity) {
// Buffer is full // Buffer is full
break break
} }
const size = ring.write(frame) const size = ring.write(frame)
if (size < frame.numberOfFrames) { if (size < frame.numberOfFrames) {
throw new Error("audio buffer is full") throw new Error("audio buffer is full")
} }
this.last = frame.timestamp this.last = frame.timestamp
frame.close() frame.close()
this.queue.shift() this.queue.shift()
} }
} }
play(play: Message.Play) { play(play: Message.Play) {
this.ring = new Ring(play.buffer) this.ring = new Ring(play.buffer)
if (!this.render) { if (!this.render) {
const sampleRate = 44100 // TODO dynamic const sampleRate = 44100 // TODO dynamic
// Refresh every half buffer // Refresh every half buffer
const refresh = ((play.buffer.capacity / sampleRate) * 1000) / 2 const refresh = ((play.buffer.capacity / sampleRate) * 1000) / 2
this.render = setInterval(this.emit.bind(this), refresh) this.render = setInterval(this.emit.bind(this), refresh)
} }
} }
} }

264
web/src/player/decoder.ts
View File

@ -5,179 +5,175 @@ import * as Stream from "../stream"
import Renderer from "./renderer" import Renderer from "./renderer"
export default class Decoder { export default class Decoder {
init: MP4.InitParser init: MP4.InitParser
decoders: Map<number, AudioDecoder | VideoDecoder> decoders: Map<number, AudioDecoder | VideoDecoder>
renderer: Renderer renderer: Renderer
constructor(renderer: Renderer) { constructor(renderer: Renderer) {
this.init = new MP4.InitParser() this.init = new MP4.InitParser()
this.decoders = new Map() this.decoders = new Map()
this.renderer = renderer this.renderer = renderer
} }
async receiveInit(msg: Message.Init) { async receiveInit(msg: Message.Init) {
const stream = new Stream.Reader(msg.reader, msg.buffer) const stream = new Stream.Reader(msg.reader, msg.buffer)
for (;;) { for (;;) {
const data = await stream.read() const data = await stream.read()
if (!data) break if (!data) break
this.init.push(data) this.init.push(data)
} }
// TODO make sure the init segment is fully received // TODO make sure the init segment is fully received
} }
async receiveSegment(msg: Message.Segment) { async receiveSegment(msg: Message.Segment) {
// Wait for the init segment to be fully received and parsed // Wait for the init segment to be fully received and parsed
const init = await this.init.info const init = await this.init.info
const input = MP4.New() const input = MP4.New()
input.onSamples = this.onSamples.bind(this) input.onSamples = this.onSamples.bind(this)
input.onReady = (track: any) => { input.onReady = (track: any) => {
// Extract all of the tracks, because we don't know if it's audio or video. // Extract all of the tracks, because we don't know if it's audio or video.
for (const i of init.tracks) { for (const i of init.tracks) {
input.setExtractionOptions(track.id, i, { nbSamples: 1 }) input.setExtractionOptions(track.id, i, { nbSamples: 1 })
} }
input.start() input.start()
} }
// MP4box requires us to reparse the init segment unfortunately // MP4box requires us to reparse the init segment unfortunately
let offset = 0 let offset = 0
for (const raw of this.init.raw) { for (const raw of this.init.raw) {
raw.fileStart = offset raw.fileStart = offset
offset = input.appendBuffer(raw) offset = input.appendBuffer(raw)
} }
const stream = new Stream.Reader(msg.reader, msg.buffer) const stream = new Stream.Reader(msg.reader, msg.buffer)
// For whatever reason, mp4box doesn't work until you read an atom at a time. // For whatever reason, mp4box doesn't work until you read an atom at a time.
while (!(await stream.done())) { while (!(await stream.done())) {
const raw = await stream.peek(4) const raw = await stream.peek(4)
// TODO this doesn't support when size = 0 (until EOF) or size = 1 (extended size) // TODO this doesn't support when size = 0 (until EOF) or size = 1 (extended size)
const size = new DataView( const size = new DataView(
raw.buffer, raw.buffer,
raw.byteOffset, raw.byteOffset,
raw.byteLength raw.byteLength
).getUint32(0) ).getUint32(0)
const atom = await stream.bytes(size) const atom = await stream.bytes(size)
// Make a copy of the atom because mp4box only accepts an ArrayBuffer unfortunately // Make a copy of the atom because mp4box only accepts an ArrayBuffer unfortunately
const box = new Uint8Array(atom.byteLength) const box = new Uint8Array(atom.byteLength)
box.set(atom) box.set(atom)
// and for some reason we need to modify the underlying ArrayBuffer with offset // and for some reason we need to modify the underlying ArrayBuffer with offset
const buffer = box.buffer as MP4.ArrayBuffer const buffer = box.buffer as MP4.ArrayBuffer
buffer.fileStart = offset buffer.fileStart = offset
// Parse the data // Parse the data
offset = input.appendBuffer(buffer) offset = input.appendBuffer(buffer)
input.flush() input.flush()
} }
} }
onSamples(track_id: number, track: MP4.Track, samples: MP4.Sample[]) { onSamples(track_id: number, track: MP4.Track, samples: MP4.Sample[]) {
let decoder = this.decoders.get(track_id) let decoder = this.decoders.get(track_id)
if (!decoder) { if (!decoder) {
// We need a sample to initalize the video decoder, because of mp4box limitations. // We need a sample to initalize the video decoder, because of mp4box limitations.
const sample = samples[0] const sample = samples[0]
if (isVideoTrack(track)) { if (isVideoTrack(track)) {
// Configure the decoder using the AVC box for H.264 // Configure the decoder using the AVC box for H.264
// TODO it should be easy to support other codecs, just need to know the right boxes. // TODO it should be easy to support other codecs, just need to know the right boxes.
const avcc = sample.description.avcC const avcc = sample.description.avcC
if (!avcc) throw new Error("TODO only h264 is supported") if (!avcc) throw new Error("TODO only h264 is supported")
const description = new MP4.Stream( const description = new MP4.Stream(new Uint8Array(avcc.size), 0, false)
new Uint8Array(avcc.size), avcc.write(description)
0,
false
)
avcc.write(description)
const videoDecoder = new VideoDecoder({ const videoDecoder = new VideoDecoder({
output: this.renderer.push.bind(this.renderer), output: this.renderer.push.bind(this.renderer),
error: console.warn, error: console.warn,
}) })
videoDecoder.configure({ videoDecoder.configure({
codec: track.codec, codec: track.codec,
codedHeight: track.video.height, codedHeight: track.video.height,
codedWidth: track.video.width, codedWidth: track.video.width,
description: description.buffer?.slice(8), description: description.buffer?.slice(8),
// optimizeForLatency: true // optimizeForLatency: true
}) })
decoder = videoDecoder decoder = videoDecoder
} else if (isAudioTrack(track)) { } else if (isAudioTrack(track)) {
const audioDecoder = new AudioDecoder({ const audioDecoder = new AudioDecoder({
output: this.renderer.push.bind(this.renderer), output: this.renderer.push.bind(this.renderer),
error: console.warn, error: console.warn,
}) })
audioDecoder.configure({ audioDecoder.configure({
codec: track.codec, codec: track.codec,
numberOfChannels: track.audio.channel_count, numberOfChannels: track.audio.channel_count,
sampleRate: track.audio.sample_rate, sampleRate: track.audio.sample_rate,
}) })
decoder = audioDecoder decoder = audioDecoder
} else { } else {
throw new Error("unknown track type") throw new Error("unknown track type")
} }
this.decoders.set(track_id, decoder) this.decoders.set(track_id, decoder)
} }
for (const sample of samples) { for (const sample of samples) {
// Convert to microseconds // Convert to microseconds
const timestamp = (1000 * 1000 * sample.dts) / sample.timescale const timestamp = (1000 * 1000 * sample.dts) / sample.timescale
const duration = (1000 * 1000 * sample.duration) / sample.timescale const duration = (1000 * 1000 * sample.duration) / sample.timescale
if (isAudioDecoder(decoder)) { if (isAudioDecoder(decoder)) {
decoder.decode( decoder.decode(
new EncodedAudioChunk({ new EncodedAudioChunk({
type: sample.is_sync ? "key" : "delta", type: sample.is_sync ? "key" : "delta",
data: sample.data, data: sample.data,
duration: duration, duration: duration,
timestamp: timestamp, timestamp: timestamp,
}) })
) )
} else if (isVideoDecoder(decoder)) { } else if (isVideoDecoder(decoder)) {
decoder.decode( decoder.decode(
new EncodedVideoChunk({ new EncodedVideoChunk({
type: sample.is_sync ? "key" : "delta", type: sample.is_sync ? "key" : "delta",
data: sample.data, data: sample.data,
duration: duration, duration: duration,
timestamp: timestamp, timestamp: timestamp,
}) })
) )
} else { } else {
throw new Error("unknown decoder type") throw new Error("unknown decoder type")
} }
} }
} }
} }
function isAudioDecoder( function isAudioDecoder(
decoder: AudioDecoder | VideoDecoder decoder: AudioDecoder | VideoDecoder
): decoder is AudioDecoder { ): decoder is AudioDecoder {
return decoder instanceof AudioDecoder return decoder instanceof AudioDecoder
} }
function isVideoDecoder( function isVideoDecoder(
decoder: AudioDecoder | VideoDecoder decoder: AudioDecoder | VideoDecoder
): decoder is VideoDecoder { ): decoder is VideoDecoder {
return decoder instanceof VideoDecoder return decoder instanceof VideoDecoder
} }
function isAudioTrack(track: MP4.Track): track is MP4.AudioTrack { function isAudioTrack(track: MP4.Track): track is MP4.AudioTrack {
return (track as MP4.AudioTrack).audio !== undefined return (track as MP4.AudioTrack).audio !== undefined
} }
function isVideoTrack(track: MP4.Track): track is MP4.VideoTrack { function isVideoTrack(track: MP4.Track): track is MP4.VideoTrack {
return (track as MP4.VideoTrack).video !== undefined return (track as MP4.VideoTrack).video !== undefined
} }

124
web/src/player/index.ts
View File

@ -3,89 +3,89 @@ import * as Ring from "./ring"
import Transport from "../transport" import Transport from "../transport"
export interface Config { export interface Config {
transport: Transport transport: Transport
canvas: OffscreenCanvas canvas: OffscreenCanvas
} }
// This class must be created on the main thread due to AudioContext. // This class must be created on the main thread due to AudioContext.
export default class Player { export default class Player {
context: AudioContext context: AudioContext
worker: Worker worker: Worker
worklet: Promise<AudioWorkletNode> worklet: Promise<AudioWorkletNode>
transport: Transport transport: Transport
constructor(config: Config) { constructor(config: Config) {
this.transport = config.transport this.transport = config.transport
this.transport.callback = this this.transport.callback = this
this.context = new AudioContext({ this.context = new AudioContext({
latencyHint: "interactive", latencyHint: "interactive",
sampleRate: 44100, sampleRate: 44100,
}) })
this.worker = this.setupWorker(config) this.worker = this.setupWorker(config)
this.worklet = this.setupWorklet(config) this.worklet = this.setupWorklet(config)
} }
private setupWorker(config: Config): Worker { private setupWorker(config: Config): Worker {
const url = new URL("worker.ts", import.meta.url) const url = new URL("worker.ts", import.meta.url)
const worker = new Worker(url, { const worker = new Worker(url, {
type: "module", type: "module",
name: "media", name: "media",
}) })
const msg = { const msg = {
canvas: config.canvas, canvas: config.canvas,
} }
worker.postMessage({ config: msg }, [msg.canvas]) worker.postMessage({ config: msg }, [msg.canvas])
return worker return worker
} }
private async setupWorklet(_config: Config): Promise<AudioWorkletNode> { private async setupWorklet(_config: Config): Promise<AudioWorkletNode> {
// Load the worklet source code. // Load the worklet source code.
const url = new URL("worklet.ts", import.meta.url) const url = new URL("worklet.ts", import.meta.url)
await this.context.audioWorklet.addModule(url) await this.context.audioWorklet.addModule(url)
const volume = this.context.createGain() const volume = this.context.createGain()
volume.gain.value = 2.0 volume.gain.value = 2.0
// Create a worklet // Create a worklet
const worklet = new AudioWorkletNode(this.context, "renderer") const worklet = new AudioWorkletNode(this.context, "renderer")
worklet.onprocessorerror = (e: Event) => { worklet.onprocessorerror = (e: Event) => {
console.error("Audio worklet error:", e) console.error("Audio worklet error:", e)
} }
// Connect the worklet to the volume node and then to the speakers // Connect the worklet to the volume node and then to the speakers
worklet.connect(volume) worklet.connect(volume)
volume.connect(this.context.destination) volume.connect(this.context.destination)
return worklet return worklet
} }
onInit(init: Message.Init) { onInit(init: Message.Init) {
this.worker.postMessage({ init }, [init.buffer.buffer, init.reader]) this.worker.postMessage({ init }, [init.buffer.buffer, init.reader])
} }
onSegment(segment: Message.Segment) { onSegment(segment: Message.Segment) {
this.worker.postMessage({ segment }, [ this.worker.postMessage({ segment }, [
segment.buffer.buffer, segment.buffer.buffer,
segment.reader, segment.reader,
]) ])
} }
async play() { async play() {
this.context.resume() this.context.resume()
const play = { const play = {
buffer: new Ring.Buffer(2, 44100 / 10), // 100ms of audio buffer: new Ring.Buffer(2, 44100 / 10), // 100ms of audio
} }
const worklet = await this.worklet const worklet = await this.worklet
worklet.port.postMessage({ play }) worklet.port.postMessage({ play })
this.worker.postMessage({ play }) this.worker.postMessage({ play })
} }
} }

16
web/src/player/message.ts
View File

@ -1,21 +1,21 @@
import * as Ring from "./ring" import * as Ring from "./ring"
export interface Config { export interface Config {
// video stuff // video stuff
canvas: OffscreenCanvas canvas: OffscreenCanvas
} }
export interface Init { export interface Init {
buffer: Uint8Array // unread buffered data buffer: Uint8Array // unread buffered data
reader: ReadableStream // unread unbuffered data reader: ReadableStream // unread unbuffered data
} }
export interface Segment { export interface Segment {
buffer: Uint8Array // unread buffered data buffer: Uint8Array // unread buffered data
reader: ReadableStream // unread unbuffered data reader: ReadableStream // unread unbuffered data
} }
export interface Play { export interface Play {
timestamp?: number timestamp?: number
buffer: Ring.Buffer buffer: Ring.Buffer
} }

42
web/src/player/renderer.ts
View File

@ -3,34 +3,34 @@ import Audio from "./audio"
import Video from "./video" import Video from "./video"
export default class Renderer { export default class Renderer {
audio: Audio audio: Audio
video: Video video: Video
constructor(config: Message.Config) { constructor(config: Message.Config) {
this.audio = new Audio(config) this.audio = new Audio(config)
this.video = new Video(config) this.video = new Video(config)
} }
push(frame: AudioData | VideoFrame) { push(frame: AudioData | VideoFrame) {
if (isAudioData(frame)) { if (isAudioData(frame)) {
this.audio.push(frame) this.audio.push(frame)
} else if (isVideoFrame(frame)) { } else if (isVideoFrame(frame)) {
this.video.push(frame) this.video.push(frame)
} else { } else {
throw new Error("unknown frame type") throw new Error("unknown frame type")
} }
} }
play(play: Message.Play) { play(play: Message.Play) {
this.audio.play(play) this.audio.play(play)
this.video.play(play) this.video.play(play)
} }
} }
function isAudioData(frame: AudioData | VideoFrame): frame is AudioData { function isAudioData(frame: AudioData | VideoFrame): frame is AudioData {
return frame instanceof AudioData return frame instanceof AudioData
} }
function isVideoFrame(frame: AudioData | VideoFrame): frame is VideoFrame { function isVideoFrame(frame: AudioData | VideoFrame): frame is VideoFrame {
return frame instanceof VideoFrame return frame instanceof VideoFrame
} }

236
web/src/player/ring.ts
View File

@ -1,159 +1,159 @@
// Ring buffer with audio samples. // Ring buffer with audio samples.
enum STATE { enum STATE {
READ_POS = 0, // The current read position READ_POS = 0, // The current read position
WRITE_POS, // The current write position WRITE_POS, // The current write position
LENGTH, // Clever way of saving the total number of enums values. LENGTH, // Clever way of saving the total number of enums values.
} }
// No prototype to make this easier to send via postMessage // No prototype to make this easier to send via postMessage
export class Buffer { export class Buffer {
state: SharedArrayBuffer state: SharedArrayBuffer
channels: SharedArrayBuffer[] channels: SharedArrayBuffer[]
capacity: number capacity: number
constructor(channels: number, capacity: number) { constructor(channels: number, capacity: number) {
// Store the current state in a separate ring buffer. // Store the current state in a separate ring buffer.
this.state = new SharedArrayBuffer( this.state = new SharedArrayBuffer(
STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT STATE.LENGTH * Int32Array.BYTES_PER_ELEMENT
) )
// Create a buffer for each audio channel // Create a buffer for each audio channel
this.channels = [] this.channels = []
for (let i = 0; i < channels; i += 1) { for (let i = 0; i < channels; i += 1) {
const buffer = new SharedArrayBuffer( const buffer = new SharedArrayBuffer(
capacity * Float32Array.BYTES_PER_ELEMENT capacity * Float32Array.BYTES_PER_ELEMENT
) )
this.channels.push(buffer) this.channels.push(buffer)
} }
this.capacity = capacity this.capacity = capacity
} }
} }
export class Ring { export class Ring {
state: Int32Array state: Int32Array
channels: Float32Array[] channels: Float32Array[]
capacity: number capacity: number
constructor(buffer: Buffer) { constructor(buffer: Buffer) {
this.state = new Int32Array(buffer.state) this.state = new Int32Array(buffer.state)
this.channels = [] this.channels = []
for (const channel of buffer.channels) { for (const channel of buffer.channels) {
this.channels.push(new Float32Array(channel)) this.channels.push(new Float32Array(channel))
} }
this.capacity = buffer.capacity this.capacity = buffer.capacity
} }
// Write samples for single audio frame, returning the total number written. // Write samples for single audio frame, returning the total number written.
write(frame: AudioData): number { write(frame: AudioData): number {
const readPos = Atomics.load(this.state, STATE.READ_POS) const readPos = Atomics.load(this.state, STATE.READ_POS)
const writePos = Atomics.load(this.state, STATE.WRITE_POS) const writePos = Atomics.load(this.state, STATE.WRITE_POS)
const startPos = writePos const startPos = writePos
let endPos = writePos + frame.numberOfFrames let endPos = writePos + frame.numberOfFrames
if (endPos > readPos + this.capacity) { if (endPos > readPos + this.capacity) {
endPos = readPos + this.capacity endPos = readPos + this.capacity
if (endPos <= startPos) { if (endPos <= startPos) {
// No space to write // No space to write
return 0 return 0
} }
} }
const startIndex = startPos % this.capacity const startIndex = startPos % this.capacity
const endIndex = endPos % this.capacity const endIndex = endPos % this.capacity
// Loop over each channel // Loop over each channel
for (let i = 0; i < this.channels.length; i += 1) { for (let i = 0; i < this.channels.length; i += 1) {
const channel = this.channels[i] const channel = this.channels[i]
if (startIndex < endIndex) { if (startIndex < endIndex) {
// One continuous range to copy. // One continuous range to copy.
const full = channel.subarray(startIndex, endIndex) const full = channel.subarray(startIndex, endIndex)
frame.copyTo(full, { frame.copyTo(full, {
planeIndex: i, planeIndex: i,
frameCount: endIndex - startIndex, frameCount: endIndex - startIndex,
}) })
} else { } else {
const first = channel.subarray(startIndex) const first = channel.subarray(startIndex)
const second = channel.subarray(0, endIndex) const second = channel.subarray(0, endIndex)
frame.copyTo(first, { frame.copyTo(first, {
planeIndex: i, planeIndex: i,
frameCount: first.length, frameCount: first.length,
}) })
// We need this conditional when startIndex == 0 and endIndex == 0 // We need this conditional when startIndex == 0 and endIndex == 0
// When capacity=4410 and frameCount=1024, this was happening 52s into the audio. // When capacity=4410 and frameCount=1024, this was happening 52s into the audio.
if (second.length) { if (second.length) {
frame.copyTo(second, { frame.copyTo(second, {
planeIndex: i, planeIndex: i,
frameOffset: first.length, frameOffset: first.length,
frameCount: second.length, frameCount: second.length,
}) })
} }
} }
} }
Atomics.store(this.state, STATE.WRITE_POS, endPos) Atomics.store(this.state, STATE.WRITE_POS, endPos)
return endPos - startPos return endPos - startPos
} }
read(dst: Float32Array[]): number { read(dst: Float32Array[]): number {
const readPos = Atomics.load(this.state, STATE.READ_POS) const readPos = Atomics.load(this.state, STATE.READ_POS)
const writePos = Atomics.load(this.state, STATE.WRITE_POS) const writePos = Atomics.load(this.state, STATE.WRITE_POS)
const startPos = readPos const startPos = readPos
let endPos = startPos + dst[0].length let endPos = startPos + dst[0].length
if (endPos > writePos) { if (endPos > writePos) {
endPos = writePos endPos = writePos
if (endPos <= startPos) { if (endPos <= startPos) {
// Nothing to read // Nothing to read
return 0 return 0
} }
} }
const startIndex = startPos % this.capacity const startIndex = startPos % this.capacity
const endIndex = endPos % this.capacity const endIndex = endPos % this.capacity
// Loop over each channel // Loop over each channel
for (let i = 0; i < dst.length; i += 1) { for (let i = 0; i < dst.length; i += 1) {
if (i >= this.channels.length) { if (i >= this.channels.length) {
// ignore excess channels // ignore excess channels
} }
const input = this.channels[i] const input = this.channels[i]
const output = dst[i] const output = dst[i]
if (startIndex < endIndex) { if (startIndex < endIndex) {
const full = input.subarray(startIndex, endIndex) const full = input.subarray(startIndex, endIndex)
output.set(full) output.set(full)
} else { } else {
const first = input.subarray(startIndex) const first = input.subarray(startIndex)
const second = input.subarray(0, endIndex) const second = input.subarray(0, endIndex)
output.set(first) output.set(first)
output.set(second, first.length) output.set(second, first.length)
} }
} }
Atomics.store(this.state, STATE.READ_POS, endPos) Atomics.store(this.state, STATE.READ_POS, endPos)
return endPos - startPos return endPos - startPos
} }
size() { size() {
// TODO is this thread safe? // TODO is this thread safe?
const readPos = Atomics.load(this.state, STATE.READ_POS) const readPos = Atomics.load(this.state, STATE.READ_POS)
const writePos = Atomics.load(this.state, STATE.WRITE_POS) const writePos = Atomics.load(this.state, STATE.WRITE_POS)
return writePos - readPos return writePos - readPos
} }
} }

152
web/src/player/video.ts
View File

@ -1,101 +1,101 @@
import * as Message from "./message" import * as Message from "./message"
export default class Video { export default class Video {
canvas: OffscreenCanvas canvas: OffscreenCanvas
queue: Array<VideoFrame> queue: Array<VideoFrame>
render: number // non-zero if requestAnimationFrame has been called render: number // non-zero if requestAnimationFrame has been called
sync?: number // the wall clock value for timestamp 0, in microseconds sync?: number // the wall clock value for timestamp 0, in microseconds
last?: number // the timestamp of the last rendered frame, in microseconds last?: number // the timestamp of the last rendered frame, in microseconds
constructor(config: Message.Config) { constructor(config: Message.Config) {
this.canvas = config.canvas this.canvas = config.canvas
this.queue = [] this.queue = []
this.render = 0 this.render = 0
} }
push(frame: VideoFrame) { push(frame: VideoFrame) {
// Drop any old frames // Drop any old frames
if (this.last && frame.timestamp <= this.last) { if (this.last && frame.timestamp <= this.last) {
frame.close() frame.close()
return return
} }
// Insert the frame into the queue sorted by timestamp. // Insert the frame into the queue sorted by timestamp.
if ( if (
this.queue.length > 0 && this.queue.length > 0 &&
this.queue[this.queue.length - 1].timestamp <= frame.timestamp this.queue[this.queue.length - 1].timestamp <= frame.timestamp
) { ) {
// Fast path because we normally append to the end. // Fast path because we normally append to the end.
this.queue.push(frame) this.queue.push(frame)
} else { } else {
// Do a full binary search // Do a full binary search
let low = 0 let low = 0
let high = this.queue.length let high = this.queue.length
while (low < high) { while (low < high) {
const mid = (low + high) >>> 1 const mid = (low + high) >>> 1
if (this.queue[mid].timestamp < frame.timestamp) low = mid + 1 if (this.queue[mid].timestamp < frame.timestamp) low = mid + 1
else high = mid else high = mid
} }
this.queue.splice(low, 0, frame) this.queue.splice(low, 0, frame)
} }
} }
draw(now: number) { draw(now: number) {
// Draw and then queue up the next draw call. // Draw and then queue up the next draw call.
this.drawOnce(now) this.drawOnce(now)
// Queue up the new draw frame. // Queue up the new draw frame.
this.render = self.requestAnimationFrame(this.draw.bind(this)) this.render = self.requestAnimationFrame(this.draw.bind(this))
} }
drawOnce(now: number) { drawOnce(now: number) {
// Convert to microseconds // Convert to microseconds
now *= 1000 now *= 1000
if (!this.queue.length) { if (!this.queue.length) {
return return
} }
let frame = this.queue[0] let frame = this.queue[0]
if (!this.sync) { if (!this.sync) {
this.sync = now - frame.timestamp this.sync = now - frame.timestamp
} }
// Determine the target timestamp. // Determine the target timestamp.
const target = now - this.sync const target = now - this.sync
if (frame.timestamp >= target) { if (frame.timestamp >= target) {
// nothing to render yet, wait for the next animation frame // nothing to render yet, wait for the next animation frame
return return
} }
this.queue.shift() this.queue.shift()
// Check if we should skip some frames // Check if we should skip some frames
while (this.queue.length) { while (this.queue.length) {
const next = this.queue[0] const next = this.queue[0]
if (next.timestamp > target) break if (next.timestamp > target) break
frame.close() frame.close()
frame = this.queue.shift()! frame = this.queue.shift()!
} }
const ctx = this.canvas.getContext("2d") const ctx = this.canvas.getContext("2d")
ctx!.drawImage(frame, 0, 0, this.canvas.width, this.canvas.height) // TODO aspect ratio ctx!.drawImage(frame, 0, 0, this.canvas.width, this.canvas.height) // TODO aspect ratio
this.last = frame.timestamp this.last = frame.timestamp
frame.close() frame.close()
} }
play(_play: Message.Play) { play(_play: Message.Play) {
// Queue up to render the next frame. // Queue up to render the next frame.
if (!this.render) { if (!this.render) {
this.render = self.requestAnimationFrame(this.draw.bind(this)) this.render = self.requestAnimationFrame(this.draw.bind(this))
} }
} }
} }

28
web/src/player/worker.ts
View File

@ -6,19 +6,19 @@ let decoder: Decoder
let renderer: Renderer let renderer: Renderer
self.addEventListener("message", async (e: MessageEvent) => { self.addEventListener("message", async (e: MessageEvent) => {
if (e.data.config) { if (e.data.config) {
const config = e.data.config as Message.Config const config = e.data.config as Message.Config
renderer = new Renderer(config) renderer = new Renderer(config)
decoder = new Decoder(renderer) decoder = new Decoder(renderer)
} else if (e.data.init) { } else if (e.data.init) {
const init = e.data.init as Message.Init const init = e.data.init as Message.Init
await decoder.receiveInit(init) await decoder.receiveInit(init)
} else if (e.data.segment) { } else if (e.data.segment) {
const segment = e.data.segment as Message.Segment const segment = e.data.segment as Message.Segment
await decoder.receiveSegment(segment) await decoder.receiveSegment(segment)
} else if (e.data.play) { } else if (e.data.play) {
const play = e.data.play as Message.Play const play = e.data.play as Message.Play
await renderer.play(play) await renderer.play(play)
} }
}) })

72
web/src/player/worklet.ts
View File

@ -7,51 +7,51 @@ import * as Message from "./message"
import { Ring } from "./ring" import { Ring } from "./ring"
class Renderer extends AudioWorkletProcessor { class Renderer extends AudioWorkletProcessor {
ring?: Ring ring?: Ring
base: number base: number
constructor(_params: AudioWorkletNodeOptions) { constructor(_params: AudioWorkletNodeOptions) {
// The super constructor call is required. // The super constructor call is required.
super() super()
this.base = 0 this.base = 0
this.port.onmessage = this.onMessage.bind(this) this.port.onmessage = this.onMessage.bind(this)
} }
onMessage(e: MessageEvent) { onMessage(e: MessageEvent) {
if (e.data.play) { if (e.data.play) {
this.onPlay(e.data.play) this.onPlay(e.data.play)
} }
} }
onPlay(play: Message.Play) { onPlay(play: Message.Play) {
this.ring = new Ring(play.buffer) this.ring = new Ring(play.buffer)
} }
// Inputs and outputs in groups of 128 samples. // Inputs and outputs in groups of 128 samples.
process( process(
inputs: Float32Array[][], inputs: Float32Array[][],
outputs: Float32Array[][], outputs: Float32Array[][],
_parameters: Record<string, Float32Array> _parameters: Record<string, Float32Array>
): boolean { ): boolean {
if (!this.ring) { if (!this.ring) {
// Paused // Paused
return true return true
} }
if (inputs.length != 1 && outputs.length != 1) { if (inputs.length != 1 && outputs.length != 1) {
throw new Error("only a single track is supported") throw new Error("only a single track is supported")
} }
const output = outputs[0] const output = outputs[0]
const size = this.ring.read(output) const size = this.ring.read(output)
if (size < output.length) { if (size < output.length) {
// TODO trigger rebuffering event // TODO trigger rebuffering event
} }
return true return true
} }
} }
registerProcessor("renderer", Renderer) registerProcessor("renderer", Renderer)

347
web/src/stream/reader.ts
View File

@ -1,219 +1,210 @@
// Reader wraps a stream and provides convience methods for reading pieces from a stream // Reader wraps a stream and provides convience methods for reading pieces from a stream
export default class Reader { export default class Reader {
reader: ReadableStream reader: ReadableStream
buffer: Uint8Array buffer: Uint8Array
constructor( constructor(reader: ReadableStream, buffer: Uint8Array = new Uint8Array(0)) {
reader: ReadableStream, this.reader = reader
buffer: Uint8Array = new Uint8Array(0) this.buffer = buffer
) { }
this.reader = reader
this.buffer = buffer
}
// Returns any number of bytes // Returns any number of bytes
async read(): Promise<Uint8Array | undefined> { async read(): Promise<Uint8Array | undefined> {
if (this.buffer.byteLength) { if (this.buffer.byteLength) {
const buffer = this.buffer const buffer = this.buffer
this.buffer = new Uint8Array() this.buffer = new Uint8Array()
return buffer return buffer
} }
const r = this.reader.getReader() const r = this.reader.getReader()
const result = await r.read() const result = await r.read()
r.releaseLock() r.releaseLock()
return result.value return result.value
} }
async readAll(): Promise<Uint8Array> { async readAll(): Promise<Uint8Array> {
const r = this.reader.getReader() const r = this.reader.getReader()
for (;;) { for (;;) {
const result = await r.read() const result = await r.read()
if (result.done) { if (result.done) {
break break
} }
const buffer = new Uint8Array(result.value) const buffer = new Uint8Array(result.value)
if (this.buffer.byteLength == 0) { if (this.buffer.byteLength == 0) {
this.buffer = buffer this.buffer = buffer
} else { } else {
const temp = new Uint8Array( const temp = new Uint8Array(this.buffer.byteLength + buffer.byteLength)
this.buffer.byteLength + buffer.byteLength temp.set(this.buffer)
) temp.set(buffer, this.buffer.byteLength)
temp.set(this.buffer) this.buffer = temp
temp.set(buffer, this.buffer.byteLength) }
this.buffer = temp }
}
}
const result = this.buffer const result = this.buffer
this.buffer = new Uint8Array() this.buffer = new Uint8Array()
r.releaseLock() r.releaseLock()
return result return result
} }
async bytes(size: number): Promise<Uint8Array> { async bytes(size: number): Promise<Uint8Array> {
const r = this.reader.getReader() const r = this.reader.getReader()
while (this.buffer.byteLength < size) { while (this.buffer.byteLength < size) {
const result = await r.read() const result = await r.read()
if (result.done) { if (result.done) {
throw "short buffer" throw "short buffer"
} }
const buffer = new Uint8Array(result.value) const buffer = new Uint8Array(result.value)
if (this.buffer.byteLength == 0) { if (this.buffer.byteLength == 0) {
this.buffer = buffer this.buffer = buffer
} else { } else {
const temp = new Uint8Array( const temp = new Uint8Array(this.buffer.byteLength + buffer.byteLength)
this.buffer.byteLength + buffer.byteLength temp.set(this.buffer)
) temp.set(buffer, this.buffer.byteLength)
temp.set(this.buffer) this.buffer = temp
temp.set(buffer, this.buffer.byteLength) }
this.buffer = temp }
}
}
const result = new Uint8Array( const result = new Uint8Array(
this.buffer.buffer, this.buffer.buffer,
this.buffer.byteOffset, this.buffer.byteOffset,
size size
) )
this.buffer = new Uint8Array( this.buffer = new Uint8Array(
this.buffer.buffer, this.buffer.buffer,
this.buffer.byteOffset + size this.buffer.byteOffset + size
) )
r.releaseLock() r.releaseLock()
return result return result
} }
async peek(size: number): Promise<Uint8Array> { async peek(size: number): Promise<Uint8Array> {
const r = this.reader.getReader() const r = this.reader.getReader()
while (this.buffer.byteLength < size) { while (this.buffer.byteLength < size) {
const result = await r.read() const result = await r.read()
if (result.done) { if (result.done) {
throw "short buffer" throw "short buffer"
} }
const buffer = new Uint8Array(result.value) const buffer = new Uint8Array(result.value)
if (this.buffer.byteLength == 0) { if (this.buffer.byteLength == 0) {
this.buffer = buffer this.buffer = buffer
} else { } else {
const temp = new Uint8Array( const temp = new Uint8Array(this.buffer.byteLength + buffer.byteLength)
this.buffer.byteLength + buffer.byteLength temp.set(this.buffer)
) temp.set(buffer, this.buffer.byteLength)
temp.set(this.buffer) this.buffer = temp
temp.set(buffer, this.buffer.byteLength) }
this.buffer = temp }
}
}
const result = new Uint8Array( const result = new Uint8Array(
this.buffer.buffer, this.buffer.buffer,
this.buffer.byteOffset, this.buffer.byteOffset,
size size
) )
r.releaseLock() r.releaseLock()
return result return result
} }
async view(size: number): Promise<DataView> { async view(size: number): Promise<DataView> {
const buf = await this.bytes(size) const buf = await this.bytes(size)
return new DataView(buf.buffer, buf.byteOffset, buf.byteLength) return new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
} }
async uint8(): Promise<number> { async uint8(): Promise<number> {
const view = await this.view(1) const view = await this.view(1)
return view.getUint8(0) return view.getUint8(0)
} }
async uint16(): Promise<number> { async uint16(): Promise<number> {
const view = await this.view(2) const view = await this.view(2)
return view.getUint16(0) return view.getUint16(0)
} }
async uint32(): Promise<number> { async uint32(): Promise<number> {
const view = await this.view(4) const view = await this.view(4)
return view.getUint32(0) return view.getUint32(0)
} }
// Returns a Number using 52-bits, the max Javascript can use for integer math // Returns a Number using 52-bits, the max Javascript can use for integer math
async uint52(): Promise<number> { async uint52(): Promise<number> {
const v = await this.uint64() const v = await this.uint64()
if (v > Number.MAX_SAFE_INTEGER) { if (v > Number.MAX_SAFE_INTEGER) {
throw "overflow" throw "overflow"
} }
return Number(v) return Number(v)
} }
// Returns a Number using 52-bits, the max Javascript can use for integer math // Returns a Number using 52-bits, the max Javascript can use for integer math
async vint52(): Promise<number> { async vint52(): Promise<number> {
const v = await this.vint64() const v = await this.vint64()
if (v > Number.MAX_SAFE_INTEGER) { if (v > Number.MAX_SAFE_INTEGER) {
throw "overflow" throw "overflow"
} }
return Number(v) return Number(v)
} }
// NOTE: Returns a BigInt instead of a Number // NOTE: Returns a BigInt instead of a Number
async uint64(): Promise<bigint> { async uint64(): Promise<bigint> {
const view = await this.view(8) const view = await this.view(8)
return view.getBigUint64(0) return view.getBigUint64(0)
} }
// NOTE: Returns a BigInt instead of a Number // NOTE: Returns a BigInt instead of a Number
async vint64(): Promise<bigint> { async vint64(): Promise<bigint> {
const peek = await this.peek(1) const peek = await this.peek(1)
const first = new DataView( const first = new DataView(
peek.buffer, peek.buffer,
peek.byteOffset, peek.byteOffset,
peek.byteLength peek.byteLength
).getUint8(0) ).getUint8(0)
const size = (first & 0xc0) >> 6 const size = (first & 0xc0) >> 6
switch (size) { switch (size) {
case 0: { case 0: {
const v = await this.uint8() const v = await this.uint8()
return BigInt(v) & 0x3fn return BigInt(v) & 0x3fn
} }
case 1: { case 1: {
const v = await this.uint16() const v = await this.uint16()
return BigInt(v) & 0x3fffn return BigInt(v) & 0x3fffn
} }
case 2: { case 2: {
const v = await this.uint32() const v = await this.uint32()
return BigInt(v) & 0x3fffffffn return BigInt(v) & 0x3fffffffn
} }
case 3: { case 3: {
const v = await this.uint64() const v = await this.uint64()
return v & 0x3fffffffffffffffn return v & 0x3fffffffffffffffn
} }
default: default:
throw "impossible" throw "impossible"
} }
} }
async done(): Promise<boolean> { async done(): Promise<boolean> {
try { try {
await this.peek(1) await this.peek(1)
return false return false
} catch (err) { } catch (err) {
return true // Assume EOF return true // Assume EOF
} }
} }
} }

160
web/src/stream/writer.ts
View File

@ -1,100 +1,100 @@
// Writer wraps a stream and writes chunks of data // Writer wraps a stream and writes chunks of data
export default class Writer { export default class Writer {
buffer: ArrayBuffer buffer: ArrayBuffer
writer: WritableStreamDefaultWriter writer: WritableStreamDefaultWriter
constructor(stream: WritableStream) { constructor(stream: WritableStream) {
this.buffer = new ArrayBuffer(8) this.buffer = new ArrayBuffer(8)
this.writer = stream.getWriter() this.writer = stream.getWriter()
} }
release() { release() {
this.writer.releaseLock() this.writer.releaseLock()
} }
async close() { async close() {
return this.writer.close() return this.writer.close()
} }
async uint8(v: number) { async uint8(v: number) {
const view = new DataView(this.buffer, 0, 1) const view = new DataView(this.buffer, 0, 1)
view.setUint8(0, v) view.setUint8(0, v)
return this.writer.write(view) return this.writer.write(view)
} }
async uint16(v: number) { async uint16(v: number) {
const view = new DataView(this.buffer, 0, 2) const view = new DataView(this.buffer, 0, 2)
view.setUint16(0, v) view.setUint16(0, v)
return this.writer.write(view) return this.writer.write(view)
} }
async uint24(v: number) { async uint24(v: number) {
const v1 = (v >> 16) & 0xff const v1 = (v >> 16) & 0xff
const v2 = (v >> 8) & 0xff const v2 = (v >> 8) & 0xff
const v3 = v & 0xff const v3 = v & 0xff
const view = new DataView(this.buffer, 0, 3) const view = new DataView(this.buffer, 0, 3)
view.setUint8(0, v1) view.setUint8(0, v1)
view.setUint8(1, v2) view.setUint8(1, v2)
view.setUint8(2, v3) view.setUint8(2, v3)
return this.writer.write(view) return this.writer.write(view)
} }
async uint32(v: number) { async uint32(v: number) {
const view = new DataView(this.buffer, 0, 4) const view = new DataView(this.buffer, 0, 4)
view.setUint32(0, v) view.setUint32(0, v)
return this.writer.write(view) return this.writer.write(view)
} }
async uint52(v: number) { async uint52(v: number) {
if (v > Number.MAX_SAFE_INTEGER) { if (v > Number.MAX_SAFE_INTEGER) {
throw "value too large" throw "value too large"
} }
this.uint64(BigInt(v)) this.uint64(BigInt(v))
} }
async vint52(v: number) { async vint52(v: number) {
if (v > Number.MAX_SAFE_INTEGER) { if (v > Number.MAX_SAFE_INTEGER) {
throw "value too large" throw "value too large"
} }
if (v < 1 << 6) { if (v < 1 << 6) {
return this.uint8(v) return this.uint8(v)
} else if (v < 1 << 14) { } else if (v < 1 << 14) {
return this.uint16(v | 0x4000) return this.uint16(v | 0x4000)
} else if (v < 1 << 30) { } else if (v < 1 << 30) {
return this.uint32(v | 0x80000000) return this.uint32(v | 0x80000000)
} else { } else {
return this.uint64(BigInt(v) | 0xc000000000000000n) return this.uint64(BigInt(v) | 0xc000000000000000n)
} }
} }
async uint64(v: bigint) { async uint64(v: bigint) {
const view = new DataView(this.buffer, 0, 8) const view = new DataView(this.buffer, 0, 8)
view.setBigUint64(0, v) view.setBigUint64(0, v)
return this.writer.write(view) return this.writer.write(view)
} }
async vint64(v: bigint) { async vint64(v: bigint) {
if (v < 1 << 6) { if (v < 1 << 6) {
return this.uint8(Number(v)) return this.uint8(Number(v))
} else if (v < 1 << 14) { } else if (v < 1 << 14) {
return this.uint16(Number(v) | 0x4000) return this.uint16(Number(v) | 0x4000)
} else if (v < 1 << 30) { } else if (v < 1 << 30) {
return this.uint32(Number(v) | 0x80000000) return this.uint32(Number(v) | 0x80000000)
} else { } else {
return this.uint64(v | 0xc000000000000000n) return this.uint64(v | 0xc000000000000000n)
} }
} }
async bytes(buffer: ArrayBuffer) { async bytes(buffer: ArrayBuffer) {
return this.writer.write(buffer) return this.writer.write(buffer)
} }
async string(str: string) { async string(str: string) {
const data = new TextEncoder().encode(str) const data = new TextEncoder().encode(str)
return this.writer.write(data) return this.writer.write(data)
} }
} }

144
web/src/transport/index.ts
View File

@ -2,97 +2,95 @@ import * as Stream from "../stream"
import * as Interface from "./interface" import * as Interface from "./interface"
export interface Config { export interface Config {
url: string url: string
fingerprint?: WebTransportHash // the certificate fingerprint, temporarily needed for local development fingerprint?: WebTransportHash // the certificate fingerprint, temporarily needed for local development
} }
export default class Transport { export default class Transport {
quic: Promise<WebTransport> quic: Promise<WebTransport>
api: Promise<WritableStream> api: Promise<WritableStream>
callback?: Interface.Callback callback?: Interface.Callback
constructor(config: Config) { constructor(config: Config) {
this.quic = this.connect(config) this.quic = this.connect(config)
// Create a unidirectional stream for all of our messages // Create a unidirectional stream for all of our messages
this.api = this.quic.then((q) => { this.api = this.quic.then((q) => {
return q.createUnidirectionalStream() return q.createUnidirectionalStream()
}) })
// async functions // async functions
this.receiveStreams() this.receiveStreams()
} }
async close() { async close() {
;(await this.quic).close() ;(await this.quic).close()
} }
// Helper function to make creating a promise easier // Helper function to make creating a promise easier
private async connect(config: Config): Promise<WebTransport> { private async connect(config: Config): Promise<WebTransport> {
const options: WebTransportOptions = {} const options: WebTransportOptions = {}
if (config.fingerprint) { if (config.fingerprint) {
options.serverCertificateHashes = [config.fingerprint] options.serverCertificateHashes = [config.fingerprint]
} }
const quic = new WebTransport(config.url, options) const quic = new WebTransport(config.url, options)
await quic.ready await quic.ready
return quic return quic
} }
async sendMessage(msg: any) { async sendMessage(msg: any) {
const payload = JSON.stringify(msg) const payload = JSON.stringify(msg)
const size = payload.length + 8 const size = payload.length + 8
const stream = await this.api const stream = await this.api
const writer = new Stream.Writer(stream) const writer = new Stream.Writer(stream)
await writer.uint32(size) await writer.uint32(size)
await writer.string("warp") await writer.string("warp")
await writer.string(payload) await writer.string(payload)
writer.release() writer.release()
} }
async receiveStreams() { async receiveStreams() {
const q = await this.quic const q = await this.quic
const streams = q.incomingUnidirectionalStreams.getReader() const streams = q.incomingUnidirectionalStreams.getReader()
for (;;) { for (;;) {
const result = await streams.read() const result = await streams.read()
if (result.done) break if (result.done) break
const stream = result.value const stream = result.value
this.handleStream(stream) // don't await this.handleStream(stream) // don't await
} }
} }
async handleStream(stream: ReadableStream) { async handleStream(stream: ReadableStream) {
const r = new Stream.Reader(stream) const r = new Stream.Reader(stream)
while (!(await r.done())) { while (!(await r.done())) {
const size = await r.uint32() const size = await r.uint32()
const typ = new TextDecoder("utf-8").decode(await r.bytes(4)) const typ = new TextDecoder("utf-8").decode(await r.bytes(4))
if (typ != "warp") throw "expected warp atom" if (typ != "warp") throw "expected warp atom"
if (size < 8) throw "atom too small" if (size < 8) throw "atom too small"
const payload = new TextDecoder("utf-8").decode( const payload = new TextDecoder("utf-8").decode(await r.bytes(size - 8))
await r.bytes(size - 8) const msg = JSON.parse(payload)
)
const msg = JSON.parse(payload)
if (msg.init) { if (msg.init) {
return this.callback?.onInit({ return this.callback?.onInit({
buffer: r.buffer, buffer: r.buffer,
reader: r.reader, reader: r.reader,
}) })
} else if (msg.segment) { } else if (msg.segment) {
return this.callback?.onSegment({ return this.callback?.onSegment({
buffer: r.buffer, buffer: r.buffer,
reader: r.reader, reader: r.reader,
}) })
} else { } else {
console.warn("unknown message", msg) console.warn("unknown message", msg)
} }
} }
} }
} }

12
web/src/transport/interface.ts
View File

@ -1,14 +1,14 @@
export interface Callback { export interface Callback {
onInit(init: Init): any onInit(init: Init): any
onSegment(segment: Segment): any onSegment(segment: Segment): any
} }
export interface Init { export interface Init {
buffer: Uint8Array // unread buffered data buffer: Uint8Array // unread buffered data
reader: ReadableStream // unread unbuffered data reader: ReadableStream // unread unbuffered data
} }
export interface Segment { export interface Segment {
buffer: Uint8Array // unread buffered data buffer: Uint8Array // unread buffered data
reader: ReadableStream // unread unbuffered data reader: ReadableStream // unread unbuffered data
} }

2
web/src/transport/message.ts
View File

@ -3,5 +3,5 @@ export type Init = any
export type Segment = any export type Segment = any
export interface Debug { export interface Debug {
max_bitrate: number max_bitrate: number
} }

82
web/src/transport/webtransport.d.ts vendored
View File

@ -8,77 +8,77 @@ declare module "webtransport"
*/ */
interface WebTransportDatagramDuplexStream { interface WebTransportDatagramDuplexStream {
readonly readable: ReadableStream readonly readable: ReadableStream
readonly writable: WritableStream readonly writable: WritableStream
readonly maxDatagramSize: number readonly maxDatagramSize: number
incomingMaxAge: number incomingMaxAge: number
outgoingMaxAge: number outgoingMaxAge: number
incomingHighWaterMark: number incomingHighWaterMark: number
outgoingHighWaterMark: number outgoingHighWaterMark: number
} }
interface WebTransport { interface WebTransport {
getStats(): Promise<WebTransportStats> getStats(): Promise<WebTransportStats>
readonly ready: Promise<undefined> readonly ready: Promise<undefined>
readonly closed: Promise<WebTransportCloseInfo> readonly closed: Promise<WebTransportCloseInfo>
close(closeInfo?: WebTransportCloseInfo): undefined close(closeInfo?: WebTransportCloseInfo): undefined
readonly datagrams: WebTransportDatagramDuplexStream readonly datagrams: WebTransportDatagramDuplexStream
createBidirectionalStream(): Promise<WebTransportBidirectionalStream> createBidirectionalStream(): Promise<WebTransportBidirectionalStream>
readonly incomingBidirectionalStreams: ReadableStream readonly incomingBidirectionalStreams: ReadableStream
createUnidirectionalStream(): Promise<WritableStream> createUnidirectionalStream(): Promise<WritableStream>
readonly incomingUnidirectionalStreams: ReadableStream readonly incomingUnidirectionalStreams: ReadableStream
} }
declare const WebTransport: { declare const WebTransport: {
prototype: WebTransport prototype: WebTransport
new (url: string, options?: WebTransportOptions): WebTransport new (url: string, options?: WebTransportOptions): WebTransport
} }
interface WebTransportHash { interface WebTransportHash {
algorithm?: string algorithm?: string
value?: BufferSource value?: BufferSource
} }
interface WebTransportOptions { interface WebTransportOptions {
allowPooling?: boolean allowPooling?: boolean
serverCertificateHashes?: Array<WebTransportHash> serverCertificateHashes?: Array<WebTransportHash>
} }
interface WebTransportCloseInfo { interface WebTransportCloseInfo {
closeCode?: number closeCode?: number
reason?: string reason?: string
} }
interface WebTransportStats { interface WebTransportStats {
timestamp?: DOMHighResTimeStamp timestamp?: DOMHighResTimeStamp
bytesSent?: number bytesSent?: number
packetsSent?: number packetsSent?: number
numOutgoingStreamsCreated?: number numOutgoingStreamsCreated?: number
numIncomingStreamsCreated?: number numIncomingStreamsCreated?: number
bytesReceived?: number bytesReceived?: number
packetsReceived?: number packetsReceived?: number
minRtt?: DOMHighResTimeStamp minRtt?: DOMHighResTimeStamp
numReceivedDatagramsDropped?: number numReceivedDatagramsDropped?: number
} }
interface WebTransportBidirectionalStream { interface WebTransportBidirectionalStream {
readonly readable: ReadableStream readonly readable: ReadableStream
readonly writable: WritableStream readonly writable: WritableStream
} }
interface WebTransportError extends DOMException { interface WebTransportError extends DOMException {
readonly source: WebTransportErrorSource readonly source: WebTransportErrorSource
readonly streamErrorCode: number readonly streamErrorCode: number
} }
declare const WebTransportError: { declare const WebTransportError: {
prototype: WebTransportError prototype: WebTransportError
new (init?: WebTransportErrorInit): WebTransportError new (init?: WebTransportErrorInit): WebTransportError
} }
interface WebTransportErrorInit { interface WebTransportErrorInit {
streamErrorCode?: number streamErrorCode?: number
message?: string message?: string
} }
type WebTransportErrorSource = "stream" | "session" type WebTransportErrorSource = "stream" | "session"

32
web/src/util/deferred.ts
View File

@ -1,20 +1,20 @@
export default class Deferred<T> { export default class Deferred<T> {
promise: Promise<T> promise: Promise<T>
resolve: (value: T | PromiseLike<T>) => void resolve: (value: T | PromiseLike<T>) => void
reject: (value: T | PromiseLike<T>) => void reject: (value: T | PromiseLike<T>) => void
constructor() { constructor() {
// Set initial values so TS stops being annoying. // Set initial values so TS stops being annoying.
this.resolve = (_value: T | PromiseLike<T>) => { this.resolve = (_value: T | PromiseLike<T>) => {
/* noop */ /* noop */
} }
this.reject = (_value: T | PromiseLike<T>) => { this.reject = (_value: T | PromiseLike<T>) => {
/* noop */ /* noop */
} }
this.promise = new Promise((resolve, reject) => { this.promise = new Promise((resolve, reject) => {
this.resolve = resolve this.resolve = resolve
this.reject = reject this.reject = reject
}) })
} }
} }

14
web/tsconfig.json
View File

@ -1,9 +1,9 @@
{ {
"include": ["src/**/*"], "include": ["src/**/*"],
"compilerOptions": { "compilerOptions": {
"target": "es2022", "target": "es2022",
"module": "es2022", "module": "es2022",
"moduleResolution": "node", "moduleResolution": "node",
"strict": true "strict": true
} }
} }