opus-codec 0.0.68 → 0.0.70

package/es/opus/OpusGettersAndSetters.js

@@ -0,0 +1,212 @@
+import { Integer } from '../runtime';
+import constants from './constants';
+export class OpusGettersAndSetters {
+    #opusEncoderOffset;
+    #runtime;
+    #value;
+    constructor(runtime, opusEncoderOffset) {
+        this.#runtime = runtime;
+        this.#value = new Integer(runtime);
+        this.#opusEncoderOffset = opusEncoderOffset;
+    }
+    setComplexity(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_complexity(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getComplexity() {
+        const result = this.#runtime.originalRuntime()._opus_get_complexity(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_COMPLEXITY');
+        return this.#value.value();
+    }
+    setBitrate(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_bitrate(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getBitrate() {
+        const result = this.#runtime.originalRuntime()._opus_get_bitrate(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_BITRATE');
+        return this.#value.value();
+    }
+    setVbr(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_vbr(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getVbr() {
+        const result = this.#runtime.originalRuntime()._opus_get_vbr(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_VBR');
+        return this.#value.value();
+    }
+    setVbrConstraint(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_vbr_constraint(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getVbrConstraint() {
+        const result = this.#runtime.originalRuntime()._opus_get_vbr_constraint(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_VBR_CONSTRAINT');
+        return this.#value.value();
+    }
+    setForceChannels(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_force_channels(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getForceChannels() {
+        const result = this.#runtime.originalRuntime()._opus_get_force_channels(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_FORCE_CHANNELS');
+        return this.#value.value();
+    }
+    setMaxBandwidth(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_max_bandwidth(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getMaxBandwidth() {
+        const result = this.#runtime.originalRuntime()._opus_get_max_bandwidth(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_MAX_BANDWIDTH');
+        return this.#value.value();
+    }
+    setBandwidth(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_bandwidth(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    setSignal(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_signal(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getSignal() {
+        const result = this.#runtime.originalRuntime()._opus_get_signal(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_SIGNAL');
+        return this.#value.value();
+    }
+    setApplication(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_application(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getApplication() {
+        const result = this.#runtime.originalRuntime()._opus_get_application(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_APPLICATION');
+        return this.#value.value();
+    }
+    getLookahead() {
+        const result = this.#runtime.originalRuntime()._opus_get_lookahead(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_LOOKAHEAD');
+        return this.#value.value();
+    }
+    setInbandFec(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_inband_fec(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getInbandFec() {
+        const result = this.#runtime.originalRuntime()._opus_get_inband_fec(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_INBAND_FEC');
+        return this.#value.value();
+    }
+    setPacketLossperc(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_packet_loss_perc(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getPacketLossperc() {
+        const result = this.#runtime.originalRuntime()._opus_get_packet_loss_perc(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_PACKET_LOSS_PERC');
+        return this.#value.value();
+    }
+    setDtx(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_dtx(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getDtx() {
+        const result = this.#runtime.originalRuntime()._opus_get_dtx(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_DTX');
+        return this.#value.value();
+    }
+    setLsbDepth(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_lsb_depth(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getLsbDepth() {
+        const result = this.#runtime.originalRuntime()._opus_get_lsb_depth(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_LSB_DEPTH');
+        return this.#value.value();
+    }
+    setExpertFrameduration(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_expert_frame_duration(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getExpertFrameduration() {
+        const result = this.#runtime.originalRuntime()._opus_get_expert_frame_duration(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_EXPERT_FRAME_DURATION');
+        return this.#value.value();
+    }
+    setPredictionDisabled(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_prediction_disabled(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getPredictionDisabled() {
+        const result = this.#runtime.originalRuntime()._opus_get_prediction_disabled(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_PREDICTION_DISABLED');
+        return this.#value.value();
+    }
+    getBandwidth() {
+        const result = this.#runtime.originalRuntime()._opus_get_bandwidth(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_BANDWIDTH');
+        return this.#value.value();
+    }
+    getSampleRate() {
+        const result = this.#runtime.originalRuntime()._opus_get_sample_rate(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_SAMPLE_RATE');
+        return this.#value.value();
+    }
+    setPhaseInversiondisabled(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_phase_inversion_disabled(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getPhaseInversiondisabled() {
+        const result = this.#runtime.originalRuntime()._opus_get_phase_inversion_disabled(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_PHASE_INVERSION_DISABLED');
+        return this.#value.value();
+    }
+    getInDtx() {
+        const result = this.#runtime.originalRuntime()._opus_get_in_dtx(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_IN_DTX');
+        return this.#value.value();
+    }
+    setGain(x) {
+        const result = this.#runtime.originalRuntime()._opus_set_gain(this.#opusEncoderOffset, x);
+        return result === constants.OPUS_OK;
+    }
+    getGain() {
+        const result = this.#runtime.originalRuntime()._opus_get_gain(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_GAIN');
+        return this.#value.value();
+    }
+    getLastPacketduration() {
+        const result = this.#runtime.originalRuntime()._opus_get_last_packet_duration(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_LAST_PACKET_DURATION');
+        return this.#value.value();
+    }
+    getPitch() {
+        const result = this.#runtime.originalRuntime()._opus_get_pitch(this.#opusEncoderOffset, this.#value.offset());
+        if (result != constants.OPUS_OK)
+            throw new Error('Failed to set OPUS_GET_PITCH');
+        return this.#value.value();
+    }
+}

package/es/opus/RingBuffer.d.ts

@@ -0,0 +1,6 @@
+export default class RingBuffer {
+    #private;
+    constructor(frameSize: number);
+    write(value: Float32Array): void;
+    read(): Float32Array | null;
+}

package/es/opus/RingBuffer.js

@@ -0,0 +1,46 @@
+export default class RingBuffer {
+    #arrayBuffer;
+    #readOffset;
+    #writeOffset;
+    #frameSize;
+    constructor(frameSize) {
+        this.#readOffset = 0;
+        this.#writeOffset = 0;
+        this.#arrayBuffer = new ArrayBuffer(this.#initialSize());
+        this.#frameSize = frameSize;
+    }
+    #view() {
+        return new Float32Array(this.#arrayBuffer);
+    }
+    write(value) {
+        this.#maybeReallocate(value.length);
+        this.#view().set(value, this.#writeOffset);
+        this.#writeOffset += value.length;
+    }
+    read() {
+        const remainingBytes = this.#writeOffset - this.#readOffset;
+        if (remainingBytes >= this.#frameSize) {
+            const view = this.#view().subarray(this.#readOffset, this.#readOffset + this.#frameSize);
+            this.#readOffset += this.#frameSize;
+            if (this.#readOffset >= this.#writeOffset) {
+                this.#writeOffset = 0;
+                this.#readOffset = 0;
+            }
+            return view;
+        }
+        return null;
+    }
+    #maybeReallocate(samples) {
+        const sampleCountInBytes = samples * Float32Array.BYTES_PER_ELEMENT;
+        if (this.#view().length - this.#writeOffset <= samples) {
+            const oldArrayBuffer = this.#arrayBuffer;
+            this.#arrayBuffer = new ArrayBuffer(oldArrayBuffer.byteLength +
+                sampleCountInBytes +
+                this.#initialSize());
+            this.#view().set(new Float32Array(oldArrayBuffer));
+        }
+    }
+    #initialSize() {
+        return this.#frameSize * Float32Array.BYTES_PER_ELEMENT * 2;
+    }
+}

package/es/opus/constants.d.ts

@@ -0,0 +1,33 @@
+declare const constants: {
+    OPUS_OK: number;
+    OPUS_BAD_ARG: number;
+    OPUS_BUFFER_TOO_SMALL: number;
+    OPUS_INTERNAL_ERROR: number;
+    OPUS_INVALID_PACKET: number;
+    OPUS_UNIMPLEMENTED: number;
+    OPUS_INVALID_STATE: number;
+    '    OPUS_ALLOC_FAIL': number;
+    OPUS_AUTO: number;
+    OPUS_BITRATE_MAX: number;
+    OPUS_APPLICATION_VOIP: number;
+    OPUS_APPLICATION_AUDIO: number;
+    OPUS_APPLICATION_RESTRICTED_LOWDELAY: number;
+    OPUS_SIGNAL_VOICE: number;
+    OPUS_SIGNAL_MUSIC: number;
+    OPUS_BANDWIDTH_NARROWBAND: number;
+    OPUS_BANDWIDTH_MEDIUMBAND: number;
+    OPUS_BANDWIDTH_WIDEBAND: number;
+    OPUS_BANDWIDTH_SUPERWIDEBAND: number;
+    OPUS_BANDWIDTH_FULLBAND: number;
+    OPUS_FRAMESIZE_ARG: number;
+    OPUS_FRAMESIZE_2_5_MS: number;
+    OPUS_FRAMESIZE_5_MS: number;
+    OPUS_FRAMESIZE_10_MS: number;
+    OPUS_FRAMESIZE_20_MS: number;
+    OPUS_FRAMESIZE_40_MS: number;
+    OPUS_FRAMESIZE_60_MS: number;
+    OPUS_FRAMESIZE_80_MS: number;
+    OPUS_FRAMESIZE_100_MS: number;
+    OPUS_FRAMESIZE_120_MS: number;
+};
+export default constants;

package/es/opus/constants.js

@@ -0,0 +1,33 @@
+const constants = {
+    'OPUS_OK': 0,
+    'OPUS_BAD_ARG': -1,
+    'OPUS_BUFFER_TOO_SMALL': -2,
+    'OPUS_INTERNAL_ERROR': -3,
+    'OPUS_INVALID_PACKET': -4,
+    'OPUS_UNIMPLEMENTED': -5,
+    'OPUS_INVALID_STATE': -6,
+    '    OPUS_ALLOC_FAIL': -7,
+    'OPUS_AUTO': -1000,
+    'OPUS_BITRATE_MAX': -1,
+    'OPUS_APPLICATION_VOIP': 2048,
+    'OPUS_APPLICATION_AUDIO': 2049,
+    'OPUS_APPLICATION_RESTRICTED_LOWDELAY': 2051,
+    'OPUS_SIGNAL_VOICE': 3001,
+    'OPUS_SIGNAL_MUSIC': 3002,
+    'OPUS_BANDWIDTH_NARROWBAND': 1101,
+    'OPUS_BANDWIDTH_MEDIUMBAND': 1102,
+    'OPUS_BANDWIDTH_WIDEBAND': 1103,
+    'OPUS_BANDWIDTH_SUPERWIDEBAND': 1104,
+    'OPUS_BANDWIDTH_FULLBAND': 1105,
+    'OPUS_FRAMESIZE_ARG': 5000,
+    'OPUS_FRAMESIZE_2_5_MS': 5001,
+    'OPUS_FRAMESIZE_5_MS': 5002,
+    'OPUS_FRAMESIZE_10_MS': 5003,
+    'OPUS_FRAMESIZE_20_MS': 5004,
+    'OPUS_FRAMESIZE_40_MS': 5005,
+    'OPUS_FRAMESIZE_60_MS': 5006,
+    'OPUS_FRAMESIZE_80_MS': 5007,
+    'OPUS_FRAMESIZE_100_MS': 5008,
+    'OPUS_FRAMESIZE_120_MS': 5009,
+};
+export default constants;

package/es/opus/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Encoder } from './Encoder';
+export { default as Decoder } from './Decoder';
+export { default as RingBuffer } from './RingBuffer';
+export { default as constants } from './constants';

package/es/opus/index.js

@@ -0,0 +1,4 @@
+export { default as Encoder } from './Encoder';
+export { default as Decoder } from './Decoder';
+export { default as RingBuffer } from './RingBuffer';
+export { default as constants } from './constants';

package/es/runtime/Buffer.d.ts

@@ -0,0 +1,10 @@
+import { IResource } from "./ResourcesHolder";
+import Runtime from "./Runtime";
+export default class Buffer implements IResource {
+    #private;
+    constructor(runtime: Runtime, size: number);
+    offset(): number;
+    data(): Uint8Array;
+    size(): number;
+    destroy(): void;
+}

package/es/runtime/Buffer.js

@@ -0,0 +1,23 @@
+export default class Buffer {
+    #offset;
+    #size;
+    #runtime;
+    constructor(runtime, size) {
+        this.#runtime = runtime;
+        this.#size = size;
+        this.#offset = runtime.malloc(size);
+    }
+    offset() {
+        return this.#offset;
+    }
+    data() {
+        return this.#runtime.subarray(this.#offset, this.#offset + this.#size);
+    }
+    size() {
+        return this.#size;
+    }
+    destroy() {
+        this.#runtime.free(this.#offset);
+        this.#offset = 0;
+    }
+}

package/es/runtime/Integer.d.ts

@@ -0,0 +1,11 @@
+import { IResource } from './ResourcesHolder';
+import Runtime from './Runtime';
+export default class Integer implements IResource {
+    #private;
+    constructor(runtime: Runtime);
+    value(): number;
+    set(value: number): void;
+    size(): number;
+    offset(): number;
+    destroy(): void;
+}

package/es/runtime/Integer.js

@@ -0,0 +1,27 @@
+export default class Integer {
+    #runtime;
+    #offset;
+    constructor(runtime) {
+        this.#runtime = runtime;
+        this.#offset = runtime.malloc(runtime.originalRuntime()._size_of_int());
+    }
+    value() {
+        if (this.#runtime.originalRuntime()._size_of_int() !== 4) {
+            throw new Error('invalid integer byte size');
+        }
+        return this.#runtime.view().getInt32(this.#offset, true);
+    }
+    set(value) {
+        this.#runtime.view().setInt32(this.#offset, value, true);
+    }
+    size() {
+        return this.#runtime.originalRuntime()._size_of_int();
+    }
+    offset() {
+        return this.#offset;
+    }
+    destroy() {
+        this.#runtime.free(this.#offset);
+        this.#offset = 0;
+    }
+}

package/es/runtime/ResourcesHolder.d.ts

@@ -0,0 +1,9 @@
+export default class ResourcesHolder {
+    #private;
+    constructor();
+    add(resource: IResource): void;
+    destroy(): void;
+}
+export interface IResource {
+    destroy(): void;
+}

package/es/runtime/ResourcesHolder.js

@@ -0,0 +1,13 @@
+export default class ResourcesHolder {
+    #resources = new Set();
+    constructor() {
+    }
+    add(resource) {
+        this.#resources.add(resource);
+    }
+    destroy() {
+        for (const r of this.#resources) {
+            r.destroy();
+        }
+    }
+}

package/es/runtime/Runtime.d.ts

@@ -0,0 +1,10 @@
+import { EmscriptenRuntime } from "../native";
+export default class Runtime {
+    #private;
+    constructor(runtime: EmscriptenRuntime);
+    originalRuntime(): EmscriptenRuntime;
+    subarray(start: number, end: number): Uint8Array;
+    free(offset: number): void;
+    view(): DataView;
+    malloc(len: number): number;
+}

package/es/runtime/Runtime.js

@@ -0,0 +1,25 @@
+export default class Runtime {
+    #runtime;
+    constructor(runtime) {
+        this.#runtime = runtime;
+    }
+    originalRuntime() {
+        return this.#runtime;
+    }
+    subarray(start, end) {
+        return this.#runtime.HEAPU8.subarray(start, end);
+    }
+    free(offset) {
+        this.#runtime._free(offset);
+    }
+    view() {
+        return new DataView(this.#runtime.HEAPU8.buffer);
+    }
+    malloc(len) {
+        const offset = this.#runtime._malloc(len);
+        if (!offset) {
+            throw new Error(`failed to allocate ${len} bytes`);
+        }
+        return offset;
+    }
+}

package/es/runtime/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Integer } from './Integer';
+export { default as Runtime } from './Runtime';
+export { default as Buffer } from './Buffer';
+export { default as ResourcesHolder, IResource } from './ResourcesHolder';

package/es/runtime/index.js

@@ -0,0 +1,4 @@
+export { default as Integer } from './Integer';
+export { default as Runtime } from './Runtime';
+export { default as Buffer } from './Buffer';
+export { default as ResourcesHolder } from './ResourcesHolder';

package/native/libopusenc-cmake/src/COPYING

@@ -0,0 +1,29 @@
+Copyright (c) 1994-2013 Xiph.Org Foundation and contributors
+Copyright (c) 2017 Jean-Marc Valin
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of the Xiph.Org Foundation nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/native/libopusenc-cmake/src/README.md

@@ -0,0 +1,11 @@
+# Libopusenc
+
+The libopusenc libraries provide a high-level API for
+encoding .opus files. libopusenc depends only on libopus.
+
+The library is in very early development.
+Please give feedback
+in #opus on irc.libera.chat or at opus@xiph.org.
+
+Programming documentation is available in tree and online at
+https://opus-codec.org/docs/

package/native/opus/COPYING

@@ -0,0 +1,44 @@
+Copyright 2001-2011 Xiph.Org, Skype Limited, Octasic,
+                    Jean-Marc Valin, Timothy B. Terriberry,
+                    CSIRO, Gregory Maxwell, Mark Borgerding,
+                    Erik de Castro Lopo
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor the
+names of specific contributors, may be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Opus is subject to the royalty-free patent licenses which are
+specified at:
+
+Xiph.Org Foundation:
+https://datatracker.ietf.org/ipr/1524/
+
+Microsoft Corporation:
+https://datatracker.ietf.org/ipr/1914/
+
+Broadcom Corporation:
+https://datatracker.ietf.org/ipr/1526/