@libmedia/avutil 0.2.0

package/dist/esm/util/amf.js

@@ -0,0 +1,84 @@
+import * as is from "@libmedia/common/util/is";
+
+import * as array from "@libmedia/common/util/array";
+
+import * as object from "@libmedia/common/util/object";
+
+export async function parseObject(ioReader, endPos) {
+    return {
+        key: await ioReader.readString(await ioReader.readUint16()),
+        value: await parseValue(ioReader, endPos)
+    };
+}
+
+export async function parseValue(ioReader, endPos) {
+    let value;
+    switch (await ioReader.readUint8()) {
+      case 0:
+        value = await ioReader.readDouble();
+        break;
+
+      case 1:
+        value = !!await ioReader.readUint8();
+        break;
+
+      case 2:
+        value = await ioReader.readString(await ioReader.readUint16());
+        break;
+
+      case 3:
+        for (value = {}; ioReader.getPos() < endPos; ) {
+            const {key: key, value: val} = await parseObject(ioReader, endPos);
+            if (value[key] = val, 9 == (16777215 & await ioReader.peekUint24())) {
+                await ioReader.skip(3);
+                break;
+            }
+        }
+        break;
+
+      case 8:
+        for (value = {}, await ioReader.skip(4); ioReader.getPos() < endPos; ) {
+            const {key: key, value: val} = await parseObject(ioReader, endPos);
+            if (value[key] = val, 9 == (16777215 & await ioReader.peekUint24())) {
+                await ioReader.skip(3);
+                break;
+            }
+        }
+        break;
+
+      case 9:
+      case 5:
+        value = null;
+        break;
+
+      case 10:
+        value = [];
+        const length = await ioReader.readUint32();
+        for (let i = 0; i < length; i++) value.push(await parseValue(ioReader, endPos));
+        break;
+
+      case 11:
+        const timestamp = await ioReader.readDouble(), localTimeOffset = await ioReader.readInt16();
+        value = new Date(timestamp + 60 * localTimeOffset * 1e3);
+        break;
+
+      case 12:
+        value = await ioReader.readString(await ioReader.readUint32());
+    }
+    return value;
+}
+
+export function writeValue(ioWriter, value) {
+    is.number(value) ? (ioWriter.writeUint8(0), ioWriter.writeDouble(value)) : is.bigint(value) ? (ioWriter.writeUint8(0), 
+    ioWriter.writeDouble(Number(value))) : is.boolean(value) ? (ioWriter.writeUint8(1), 
+    ioWriter.writeUint8(value ? 1 : 0)) : is.string(value) ? value.length >= 65536 ? (ioWriter.writeUint8(12), 
+    ioWriter.writeUint32(value.length), ioWriter.writeString(value)) : (ioWriter.writeUint8(2), 
+    ioWriter.writeUint16(value.length), ioWriter.writeString(value)) : is.array(value) ? (ioWriter.writeUint8(10), 
+    ioWriter.writeUint32(value.length), array.each(value, (value => {
+        writeValue(ioWriter, value);
+    }))) : is.object(value) ? (ioWriter.writeUint8(3), object.each(value, ((item, key) => {
+        ioWriter.writeUint16(key.length), ioWriter.writeString(key), writeValue(ioWriter, item);
+    })), ioWriter.writeUint24(9)) : value instanceof Date ? (ioWriter.writeUint8(11), 
+    ioWriter.writeDouble(value.getTime()), ioWriter.writeInt16(0)) : null == value && ioWriter.writeUint8(5);
+}
+//# sourceMappingURL=amf.js.map

package/dist/esm/util/amf.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["is","array","object","async","parseObject","ioReader","endPos","key","readString","readUint16","value","parseValue","readUint8","readDouble","getPos","val","peekUint24","skip","length","readUint32","i","push","timestamp","localTimeOffset","readInt16","Date","writeValue","ioWriter","number","writeUint8","writeDouble","bigint","Number","boolean","string","writeUint32","writeString","writeUint16","each","item","writeUint24","getTime","writeInt16"],"sources":["../../../util/amf.ts"],"mappings":"YA6BYA,QAAE;;YACFC,WAAK;;YACLC,YAAM;;OAIXC,eAAeC,YAAYC,UAAmCC;IAGnE,OAAO;QACLC,WAHgBF,SAASG,iBAAiBH,SAASI;QAInDC,aAHkBC,WAAWN,UAAUC;;AAK3C;;OAIOH,eAAeQ,WAAWN,UAAmCC;IAElE,IAAII;IAEJ,cAHmBL,SAASO;MAK1B,KAAK;QACHF,cAAcL,SAASQ;QACvB;;MAEF,KAAK;QACHH,gBAAcL,SAASO;QACvB;;MAEF,KAAK;QACHF,cAAcL,SAASG,iBAAiBH,SAASI;QACjD;;MAEF,KAAK;QAEH,KADAC,QAAQ,IACDL,SAASS,WAAWR,UAAQ;YACjC,OAAMC,KAAEA,KAAKG,OAAOK,aAAcX,YAAYC,UAAUC;YAExD,IADAI,MAAMH,OAAOQ,KACwC,MAAhB,iBAAzBV,SAASW,eAAmC;sBAChDX,SAASY,KAAK;gBACpB;AACF;AACF;QACA;;MAEF,KAAK;QAIH,KAHAP,QAAQ,UAEFL,SAASY,KAAK,IACbZ,SAASS,WAAWR,UAAQ;YACjC,OAAMC,KAAEA,KAAKG,OAAOK,aAAcX,YAAYC,UAAUC;YAExD,IADAI,MAAMH,OAAOQ,KACwC,MAAhB,iBAAzBV,SAASW,eAAmC;sBAChDX,SAASY,KAAK;gBACpB;AACF;AACF;QACA;;MAEF,KAAK;MACL,KAAK;QACHP,QAAQ;QACR;;MAEF,KAAK;QACHA,QAAQ;QACR,MAAMQ,eAAeb,SAASc;QAC9B,KAAK,IAAIC,IAAI,GAAGA,IAAIF,QAAQE,KAC1BV,MAAMW,WAAWV,WAAWN,UAAUC;QAExC;;MAEF,KAAK;QACH,MAAMgB,kBAAkBjB,SAASQ,cAC3BU,wBAAwBlB,SAASmB;QACvCd,QAAQ,IAAIe,KAAKH,YAA8B,KAAlBC,kBAAuB;QACpD;;MAEF,KAAK;QACHb,cAAcL,SAASG,iBAAiBH,SAASc;;IAMrD,OAAOT;AACT;;OAEM,SAAUgB,WAAWC,UAAuCjB;IAE5DV,GAAG4B,OAAOlB,UACZiB,SAASE,WAAW,IACpBF,SAASG,YAAYpB,UAEdV,GAAG+B,OAAOrB,UACjBiB,SAASE,WAAW;IACpBF,SAASG,YAAYE,OAAOtB,WAGrBV,GAAGiC,QAAQvB,UAClBiB,SAASE,WAAW;IACpBF,SAASE,WAAWnB,QAAQ,IAAI,MAGzBV,GAAGkC,OAAOxB,SAEbA,MAAMQ,UAAU,SAClBS,SAASE,WAAW;IACpBF,SAASQ,YAAYzB,MAAMQ,SAC3BS,SAASS,YAAY1B,WAIrBiB,SAASE,WAAW;IACpBF,SAASU,YAAY3B,MAAMQ,SAC3BS,SAASS,YAAY1B,UAIhBV,GAAGC,MAAMS,UAChBiB,SAASE,WAAW;IACpBF,SAASQ,YAAYzB,MAAMQ,SAC3BjB,MAAMqC,KAAK5B,QAAQA;QACjBgB,WAAWC,UAAUjB;AAAM,WAItBV,GAAGE,OAAOQ,UACjBiB,SAASE,WAAW,IACpB3B,OAAOoC,KAAK5B,QAAO,CAAC6B,MAAMhC;QACxBoB,SAASU,YAAY9B,IAAIW,SACzBS,SAASS,YAAY7B,MACrBmB,WAAWC,UAAUY;AAAK,SAG5BZ,SAASa,YAAY,MAEd9B,iBAAiBe,QACxBE,SAASE,WAAW;IACpBF,SAASG,YAAYpB,MAAM+B,YAC3Bd,SAASe,WAAW,MAEJ,QAAThC,SACPiB,SAASE,WAAW;AAExB","ignoreList":[]}

package/dist/esm/util/av1syntax.d.ts

@@ -0,0 +1,9 @@
+import BitReader from "@libmedia/common/io/BitReader";
+export declare function f(bitReader: BitReader, n: number): number;
+export declare function uvlc(bitReader: BitReader): number;
+export declare function le(bitReader: BitReader, n: number): number;
+export declare function leb128(bitReader: BitReader): number;
+export declare function su(bitReader: BitReader, n: number): number;
+export declare function ns(bitReader: BitReader, n: number): number;
+export declare function L(bitReader: BitReader, n: number): number;
+export declare function NS(bitReader: BitReader, n: number): number;

package/dist/esm/util/av1syntax.js

@@ -0,0 +1,54 @@
+export function f(bitReader, n) {
+    let x = 0;
+    for (let i = 0; i < n; i++) x = 2 * x + bitReader.readU1();
+    return x;
+}
+
+export function uvlc(bitReader) {
+    let leadingZeros = 0;
+    for (;;) {
+        if (f(bitReader, 1)) break;
+        leadingZeros++;
+    }
+    if (leadingZeros >= 32) return 0;
+    return f(bitReader, leadingZeros) + (1 << leadingZeros) - 1;
+}
+
+export function le(bitReader, n) {
+    let t = 0;
+    for (let i = 0; i < n; i++) {
+        t += f(bitReader, 8) << 8 * i;
+    }
+    return t;
+}
+
+export function leb128(bitReader) {
+    let value = 0;
+    for (let i = 0; i < 8; i++) {
+        let next = f(bitReader, 8);
+        if (value |= (127 & next) << 7 * i, !(128 & next)) break;
+    }
+    return value;
+}
+
+export function su(bitReader, n) {
+    let value = f(bitReader, n), signMask = 1 << n - 1;
+    return value & signMask && (value -= 2 * signMask), value;
+}
+
+export function ns(bitReader, n) {
+    let w = Math.floor(Math.log2(n)) + 1, m = (1 << w) - n, v = f(bitReader, w - 1);
+    return v < m ? v : (v << 1) - m + f(bitReader, 1);
+}
+
+export function L(bitReader, n) {
+    let x = 0;
+    for (let i = 0; i < n; i++) x = 2 * x + bitReader.readU1();
+    return x;
+}
+
+export function NS(bitReader, n) {
+    let w = Math.floor(Math.log2(n)) + 1, m = (1 << w) - n, v = L(bitReader, w - 1);
+    return v < m ? v : (v << 1) - m + L(bitReader, 1);
+}
+//# sourceMappingURL=av1syntax.js.map

package/dist/esm/util/av1syntax.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["f","bitReader","n","x","i","readU1","uvlc","leadingZeros","le","t","leb128","value","next","su","signMask","ns","w","Math","floor","log2","m","v","L","NS"],"sources":["../../../util/av1syntax.ts"],"mappings":"OA2BM,SAAUA,EAAEC,WAAsBC;IACtC,IAAIC,IAAI;IACR,KAAK,IAAIC,IAAI,GAAGA,IAAIF,GAAGE,KACrBD,IAAI,IAAIA,IAAIF,UAAUI;IAExB,OAAOF;AACT;;OAEM,SAAUG,KAAKL;IACnB,IAAIM,eAAe;IACnB,SAAa;QAEX,IADWP,EAAEC,WAAW,IAEtB;QAEFM;AACF;IACA,IAAIA,gBAAgB,IAClB,OAAO;IAGT,OADcP,EAAEC,WAAWM,iBACX,KAAKA,gBAAgB;AACvC;;OAEM,SAAUC,GAAGP,WAAsBC;IACvC,IAAIO,IAAI;IACR,KAAK,IAAIL,IAAI,GAAGA,IAAIF,GAAGE,KAAK;QAE1BK,KADWT,EAAEC,WAAW,MACL,IAAJG;AACjB;IACA,OAAOK;AACT;;OAEM,SAAUC,OAAOT;IACrB,IAAIU,QAAQ;IACZ,KAAK,IAAIP,IAAI,GAAGA,IAAI,GAAGA,KAAM;QAC3B,IAAIQ,OAAOZ,EAAEC,WAAW;QAExB,IADAU,UAAkB,MAAPC,SAAqB,IAAJR,KACf,MAAPQ,OACJ;AAEJ;IACA,OAAOD;AACT;;OAEM,SAAUE,GAAGZ,WAAsBC;IACvC,IAAIS,QAAQX,EAAEC,WAAWC,IACrBY,WAAW,KAAMZ,IAAI;IAIzB,OAHIS,QAAQG,aACVH,SAAgB,IAAIG,WAEfH;AACT;;OAEM,SAAUI,GAAGd,WAAsBC;IACvC,IAAIc,IAAIC,KAAKC,MAAMD,KAAKE,KAAKjB,MAAM,GAC/BkB,KAAK,KAAKJ,KAAKd,GACfmB,IAAIrB,EAAEC,WAAWe,IAAI;IACzB,OAAIK,IAAID,IACCC,KAGDA,KAAK,KAAKD,IADHpB,EAAEC,WAAW;AAE9B;;OAEM,SAAUqB,EAAErB,WAAsBC;IACtC,IAAIC,IAAI;IACR,KAAK,IAAIC,IAAI,GAAIA,IAAIF,GAAGE,KACtBD,IAAI,IAAIA,IAAIF,UAAUI;IAExB,OAAOF;AACT;;OAEM,SAAUoB,GAAGtB,WAAsBC;IACvC,IAAIc,IAAIC,KAAKC,MAAMD,KAAKE,KAAKjB,MAAM,GAC/BkB,KAAK,KAAKJ,KAAKd,GACfmB,IAAIC,EAAErB,WAAWe,IAAI;IACzB,OAAIK,IAAID,IACCC,KAGDA,KAAK,KAAKD,IADHE,EAAErB,WAAW;AAE9B","ignoreList":[]}

package/dist/esm/util/avbuffer.d.ts

@@ -0,0 +1,17 @@
+import { AVBuffer, AVBufferPool, AVBufferRef } from "../struct/avbuffer";
+export declare function bufferCreate(buf: pointer<AVBuffer>, data: pointer<uint8>, size: size, free?: pointer<(opaque: pointer<void>, data: pointer<uint8>) => void>, opaque?: pointer<void>, flags?: int32): pointer<AVBufferRef>;
+export declare function avbufferCreate(data: pointer<uint8>, size: size, free?: pointer<(opaque: pointer<void>, data: pointer<uint8>) => void>, opaque?: pointer<void>, flags?: int32): pointer<AVBufferRef>;
+export declare function avbufferAlloc(size: size): pointer<AVBufferRef>;
+export declare function avbufferAllocz(size: size): pointer<AVBufferRef>;
+export declare function avbufferRef(buf: pointer<AVBufferRef>): pointer<AVBufferRef>;
+export declare function bufferReplace(dst: pointer<pointer<AVBufferRef>>, src: pointer<pointer<AVBufferRef>>): void;
+export declare function avbufferUnref(buf: pointer<pointer<AVBufferRef>>): void;
+export declare function avbufferIsWritable(buf: pointer<AVBufferRef>): 0 | 1;
+export declare function avbufferGetOpaque(buf: pointer<AVBufferRef>): pointer<void>;
+export declare function avbufferGetRefCount(buf: pointer<AVBufferRef>): uint32;
+export declare function avbufferMakeWritable(pbuf: pointer<pointer<AVBufferRef>>): 0 | -1;
+export declare function avbufferReplace(pdst: pointer<pointer<AVBufferRef>>, src: pointer<AVBufferRef>): number;
+export declare function avbufferRealloc(pdst: pointer<pointer<AVBufferRef>>, size: size): any;
+export declare function bufferPoolFlush(pool: pointer<AVBufferPool>): void;
+export declare function bufferPoolFree(pool: pointer<AVBufferPool>): void;
+export declare function poolReleaseBuffer(opaque: pointer<void>, data: pointer<void>): void;

package/dist/esm/util/avbuffer.js

@@ -0,0 +1,138 @@
+import { memcpy as cheap__memcpy__18 } from "@libmedia/cheap/std/memory";
+
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { Mutex as cheap__Mutex__93 } from "@libmedia/cheap/thread/mutex";
+
+import cheap__structAccess__94 from "@libmedia/cheap/std/structAccess";
+
+import { avFree, avFreep, avMalloc, avMallocz, avRealloc } from "./mem";
+
+import * as atomics from "@libmedia/cheap/thread/atomics";
+
+import { memcpy, memset } from "@libmedia/cheap/std/memory";
+
+import { AVBuffer, AVBufferRef } from "../struct/avbuffer";
+
+import * as mutex from "@libmedia/cheap/thread/mutex";
+
+import * as stack from "@libmedia/cheap/stack";
+
+export function bufferCreate(buf, data, size, free = 0, opaque = 0, flags = 0) {
+    cheap__CTypeEnumWrite__1[20](buf, data), cheap__CTypeEnumWrite__1[15](buf + 4, size), 
+    cheap__CTypeEnumWrite__1[20](buf + 12, free), cheap__CTypeEnumWrite__1[20](buf + 16, opaque), 
+    atomics.store(buf + 8, 1, 9, 2), cheap__CTypeEnumWrite__1[15](buf + 20, flags);
+    const ref = avMallocz(12);
+    return ref ? (cheap__CTypeEnumWrite__1[20](ref, buf), cheap__CTypeEnumWrite__1[20](ref + 4, data), 
+    cheap__CTypeEnumWrite__1[15](ref + 8, size), ref) : 0;
+}
+
+export function avbufferCreate(data, size, free = 0, opaque = 0, flags = 0) {
+    const buf = avMallocz(28);
+    if (!buf) return 0;
+    const ref = bufferCreate(buf, data, size, free, opaque, flags);
+    return ref || (avFree(buf), 0);
+}
+
+export function avbufferAlloc(size) {
+    return avbufferCreate(avMalloc(size), size);
+}
+
+export function avbufferAllocz(size) {
+    const p = avbufferAlloc(size);
+    return memset(cheap__CTypeEnumRead__0[20](p + 4), 0, size), p;
+}
+
+export function avbufferRef(buf) {
+    const ref = avMallocz(12);
+    return cheap__memcpy__18(ref, buf, 12), atomics.add(cheap__CTypeEnumRead__0[20](buf) + 8, 1, 9, 2), 
+    ref;
+}
+
+export function bufferReplace(dst, src) {
+    const buf = cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst));
+    if (src ? (cheap__memcpy__18(cheap__CTypeEnumRead__0[20](dst), cheap__CTypeEnumRead__0[20](src), 12), 
+    avFreep(src)) : avFreep(dst), 1 === atomics.sub(buf + 8, 1, 9, 2)) {
+        const freeAvbuffer = !(2 & cheap__CTypeEnumRead__0[15](buf + 24));
+        cheap__CTypeEnumRead__0[20](buf + 16) ? poolReleaseBuffer(cheap__CTypeEnumRead__0[20](buf + 16), cheap__CTypeEnumRead__0[20](buf)) : avFree(cheap__CTypeEnumRead__0[20](buf)), 
+        freeAvbuffer && avFree(buf);
+    }
+}
+
+export function avbufferUnref(buf) {
+    buf && cheap__CTypeEnumRead__0[20](buf) && bufferReplace(buf, 0);
+}
+
+export function avbufferIsWritable(buf) {
+    return 1 & cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](buf) + 20) ? 0 : 1 === atomics.load(cheap__CTypeEnumRead__0[20](buf) + 8, 9, 2) ? 1 : 0;
+}
+
+export function avbufferGetOpaque(buf) {
+    return cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](buf) + 16);
+}
+
+export function avbufferGetRefCount(buf) {
+    return atomics.load(cheap__CTypeEnumRead__0[20](buf) + 8, 9, 2);
+}
+
+export function avbufferMakeWritable(pbuf) {
+    const buf = cheap__CTypeEnumRead__0[20](pbuf);
+    if (!buf) return -1;
+    if (avbufferIsWritable(buf)) return 0;
+    const newbuf = avbufferAlloc(cheap__CTypeEnumRead__0[15](buf + 8));
+    memcpy(cheap__CTypeEnumRead__0[20](newbuf + 4), cheap__CTypeEnumRead__0[20](buf + 4), cheap__CTypeEnumRead__0[15](buf + 8));
+    let newbufp = stack.malloc(4);
+    return cheap__CTypeEnumWrite__1[20](newbufp, newbuf), bufferReplace(pbuf, newbufp), 
+    stack.free(4), 0;
+}
+
+export function avbufferReplace(pdst, src) {
+    const dst = cheap__CTypeEnumRead__0[20](pdst);
+    if (!src) return avbufferUnref(pdst), 0;
+    if (dst && cheap__CTypeEnumRead__0[20](dst + 4) === cheap__CTypeEnumRead__0[20](src + 4)) return cheap__CTypeEnumWrite__1[20](dst + 4, cheap__CTypeEnumRead__0[20](src + 4)), 
+    cheap__CTypeEnumWrite__1[15](dst + 8, cheap__CTypeEnumRead__0[15](src + 8)), 0;
+    const tmp = avbufferRef(src);
+    return avbufferUnref(pdst), cheap__CTypeEnumWrite__1[20](pdst, tmp), 0;
+}
+
+export function avbufferRealloc(pdst, size) {
+    if (!cheap__CTypeEnumRead__0[20](pdst)) {
+        const buf = avbufferCreate(avRealloc(0, size), size);
+        return cheap__CTypeEnumWrite__1[20](pdst, buf), cheap__CTypeEnumWrite__1[15](cheap__CTypeEnumRead__0[20](buf) + 24, 1 | cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](buf) + 24)), 
+        0;
+    }
+    const ref = cheap__CTypeEnumRead__0[20](pdst), buf = cheap__CTypeEnumRead__0[20](ref);
+    if (cheap__CTypeEnumRead__0[15](ref + 8) === size) return 0;
+    if (!(1 & cheap__CTypeEnumRead__0[15](buf + 24) && avbufferIsWritable(ref) && cheap__CTypeEnumRead__0[20](ref + 4) === cheap__CTypeEnumRead__0[20](buf))) {
+        let newRef = stack.malloc(4);
+        cheap__CTypeEnumWrite__1[20](newRef, 0);
+        const ret = avbufferRealloc(newRef, size);
+        return ret < 0 ? (stack.free(4), ret) : (memcpy(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](newRef) + 4), cheap__CTypeEnumRead__0[20](buf), Math.min(size, cheap__CTypeEnumRead__0[15](buf + 4))), 
+        bufferReplace(pdst, newRef), stack.free(4), 0);
+    }
+    const tmp = avRealloc(cheap__CTypeEnumRead__0[20](buf), size);
+    return cheap__CTypeEnumWrite__1[20](ref + 4, tmp), cheap__CTypeEnumWrite__1[20](buf, tmp), 
+    cheap__CTypeEnumWrite__1[15](ref + 8, size), cheap__CTypeEnumWrite__1[15](buf + 4, size), 
+    0;
+}
+
+export function bufferPoolFlush(pool) {
+    for (;cheap__CTypeEnumRead__0[20](pool + 4); ) {
+        const buf = cheap__CTypeEnumRead__0[20](pool + 4);
+        cheap__CTypeEnumWrite__1[20](pool + 4, cheap__CTypeEnumRead__0[20](buf + 16)), cheap__CTypeEnumRead__0[20](buf + 4) ? poolReleaseBuffer(cheap__CTypeEnumRead__0[20](buf + 4), cheap__CTypeEnumRead__0[20](buf)) : avFree(cheap__CTypeEnumRead__0[20](buf)), 
+        avFree(buf);
+    }
+}
+
+export function bufferPoolFree(pool) {
+    bufferPoolFlush(pool), mutex.destroy(pool), avFree(pool);
+}
+
+export function poolReleaseBuffer(opaque, data) {
+    const buf = opaque, pool = cheap__CTypeEnumRead__0[20](buf + 12);
+    mutex.lock(pool), cheap__CTypeEnumWrite__1[20](buf + 16, cheap__CTypeEnumRead__0[20](pool + 4)), 
+    cheap__CTypeEnumWrite__1[20](pool + 4, buf), mutex.unlock(pool), 1 === atomics.sub(pool + 8, 1, 9, 2) && bufferPoolFree(pool);
+}
+//# sourceMappingURL=avbuffer.js.map

package/dist/esm/util/avbuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["avFree","avFreep","avMalloc","avMallocz","avRealloc","atomics","memcpy","memset","AVBuffer","AVBufferRef","mutex","stack","bufferCreate","buf","data","size","free","opaque","flags","cheap__CTypeEnumWrite__1","store","ref","avbufferCreate","avbufferAlloc","avbufferAllocz","p","cheap__CTypeEnumRead__0","avbufferRef","cheap__memcpy__18","add","bufferReplace","dst","src","sub","freeAvbuffer","poolReleaseBuffer","avbufferUnref","avbufferIsWritable","load","avbufferGetOpaque","avbufferGetRefCount","avbufferMakeWritable","pbuf","newbuf","newbufp","malloc","avbufferReplace","pdst","tmp","avbufferRealloc","newRef","ret","Math","min","bufferPoolFlush","pool","bufferPoolFree","destroy","lock","unlock"],"sources":["../../../util/avbuffer.ts"],"mappings":"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","ignoreList":[]}

package/dist/esm/util/avdict.d.ts

@@ -0,0 +1,8 @@
+import { AVDictionary, AVDictionaryEntry } from "../struct/avdict";
+export declare function freeAVDict(pm: pointer<pointer<AVDictionary>>): void;
+export declare function freeAVDict2(m: pointer<AVDictionary>): void;
+export declare function avDictCount(m: pointer<AVDictionary>): 0 | int32;
+export declare function avDictIterate(m: pointer<AVDictionary>, prev: pointer<AVDictionaryEntry>): pointer<AVDictionaryEntry>;
+export declare function avDictGet(m: pointer<AVDictionary>, key: string, prev?: pointer<AVDictionaryEntry>, flags?: int32): pointer<AVDictionaryEntry>;
+export declare function avDictSet(m: pointer<AVDictionary>, key: string, value: string, flags?: int32): number;
+export declare function avDictCopy(dst: pointer<AVDictionary>, src: pointer<AVDictionary>, flags: int32): number;

package/dist/esm/util/avdict.js

@@ -0,0 +1,77 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__3 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { AVDictionaryEntry as cheap__AVDictionaryEntry__16 } from "../struct/avdict";
+
+import cheap__structAccess__17 from "@libmedia/cheap/std/structAccess";
+
+import { Allocator as cheap__Allocator__20 } from "@libmedia/cheap/heap";
+
+import { readCString, writeCString } from "@libmedia/cheap/std/memory";
+
+import { AVDictionaryEntry } from "../struct/avdict";
+
+import { avFreep } from "./mem";
+
+export function freeAVDict(pm) {
+    freeAVDict2(cheap__CTypeEnumRead__0[20](pm)), avFreep(pm);
+}
+
+export function freeAVDict2(m) {
+    if (m) {
+        for (;cheap__CTypeEnumWrite__3[15](m, cheap__CTypeEnumRead__0[15](m) - 1), cheap__CTypeEnumRead__0[15](m) + 1; ) avFreep(cheap__CTypeEnumRead__0[20](m + 4) + 8 * cheap__CTypeEnumRead__0[15](m)), 
+        avFreep(cheap__CTypeEnumRead__0[20](m + 4) + 8 * cheap__CTypeEnumRead__0[15](m) + 4);
+        avFreep(m + 4);
+    }
+}
+
+export function avDictCount(m) {
+    return m ? cheap__CTypeEnumRead__0[15](m) : 0;
+}
+
+export function avDictIterate(m, prev) {
+    let i = 0;
+    return m ? (prev && (i = 1 + (prev - cheap__CTypeEnumRead__0[20](m + 4) >>> 3)), 
+    i >= cheap__CTypeEnumRead__0[15](m) ? 0 : cheap__CTypeEnumRead__0[20](m + 4) + 8 * i) : 0;
+}
+
+export function avDictGet(m, key, prev = 0, flags = 0) {
+    if (!m) return 0;
+    let entry = prev;
+    if (!key) return 0;
+    for (;entry = avDictIterate(m, entry); ) {
+        let s = readCString(cheap__CTypeEnumRead__0[20](entry));
+        if (1 & flags && (s.toLocaleLowerCase(), key.toLocaleLowerCase()), s === key || 2 & flags && 0 === s.indexOf(key)) return entry;
+    }
+}
+
+export function avDictSet(m, key, value, flags = 0) {
+    if (!m) throw new Error("m is nullptr");
+    let tag = 0;
+    if (64 & flags && (tag = avDictGet(m, key, 0, flags)), tag) {
+        if (16 & flags) return 0;
+        32 & flags && (value = `${readCString(cheap__CTypeEnumRead__0[20](tag + 4))},${value}`), 
+        cheap__Allocator__20.free(cheap__CTypeEnumRead__0[20](tag + 4)), cheap__CTypeEnumWrite__3[20](tag + 4, cheap__Allocator__20.malloc(value.length + 1)), 
+        writeCString(cheap__CTypeEnumRead__0[20](tag + 4), value, value.length);
+    } else {
+        let tmp = cheap__Allocator__20.realloc(cheap__CTypeEnumRead__0[20](m + 4), 8 * (cheap__CTypeEnumRead__0[15](m) + 1));
+        cheap__CTypeEnumWrite__3[20](m + 4, tmp), cheap__CTypeEnumWrite__3[20](cheap__CTypeEnumRead__0[20](m + 4) + 8 * cheap__CTypeEnumRead__0[15](m), cheap__Allocator__20.malloc(key.length + 1)), 
+        cheap__CTypeEnumWrite__3[20](cheap__CTypeEnumRead__0[20](m + 4) + 8 * cheap__CTypeEnumRead__0[15](m) + 4, cheap__Allocator__20.malloc(value.length + 1)), 
+        writeCString(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](m + 4) + 8 * cheap__CTypeEnumRead__0[15](m)), key, key.length), 
+        writeCString(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](m + 4) + 8 * cheap__CTypeEnumRead__0[15](m) + 4), value, value.length), 
+        cheap__CTypeEnumWrite__3[15](m, cheap__CTypeEnumRead__0[15](m) + 1);
+    }
+    return 0;
+}
+
+export function avDictCopy(dst, src, flags) {
+    if (!dst || !src) return -1;
+    let t = 0;
+    for (;t = avDictIterate(src, t); ) {
+        let ret = avDictSet(dst, readCString(cheap__CTypeEnumRead__0[20](t)), readCString(cheap__CTypeEnumRead__0[20](t + 4)), flags);
+        if (ret < 0) return ret;
+    }
+    return 0;
+}
+//# sourceMappingURL=avdict.js.map

package/dist/esm/util/avdict.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["readCString","writeCString","AVDictionaryEntry","avFreep","freeAVDict","pm","freeAVDict2","cheap__CTypeEnumRead__0","m","cheap__CTypeEnumWrite__3","avDictCount","avDictIterate","prev","i","avDictGet","key","flags","entry","s","toLocaleLowerCase","indexOf","avDictSet","value","Error","tag","cheap__Allocator__20","free","malloc","length","tmp","realloc","avDictCopy","dst","src","t","ret"],"sources":["../../../util/avdict.ts"],"mappings":";;;;;;;;;;SAyBSA,aAAaC,oBAAc;;SACAC,yBAAmB;;SAC9CC,eAAS;;OAEZ,SAAUC,WAAWC;IACzBC,YAAWC,wBAAA,IAAUF,MACrBF,QAAQE;AACV;;OAEM,SAAUC,YAAYE;IAC1B,IAAIA,GAAG;QACL,MAAAC,yBAAA,IAAOD,GAACD,wBAAA,IAADC,KAAC,IAAAD,wBAAA,IAADC,KAAC,KACNL,QAAOI,wBAAA,IAAWC,IAAC,KAAQ,IAARD,wBAAA,IAAOC;QAC1BL,QAAOI,wBAAA,IAAWC,IAAC,KAAQ,IAARD,wBAAA,IAAOC,KAAC;QAE7BL,QAAkBK,IAAC;AACrB;AACF;;OAEM,SAAUE,YAAYF;IAC1B,OAAOA,IAAGD,wBAAA,IAACC,KAAU;AACvB;;OAEM,SAAUG,cAAcH,GAA0BI;IAEtD,IAAIC,IAAI;IACR,OAAKL,KAGDI,SACFC,IAAqB,KAAjBD,OAAIL,wBAAA,IAAGC,IAAC;IAKVK,KAACN,wBAAA,IAAIC,KACP,IAEFD,wBAAA,IAAiBC,IAAC,KAAQ,IAADK,KAXvB;AAYJ;;OAEM,SAAUC,UAAUN,GAA0BO,KAAaH,OAAA,GAA4CI,QAAe;IAE1H,KAAKR,GACH;IAGF,IAAIS,QAAoCL;IAExC,KAAKG,KACH;IAGF,MAAQE,QAAQN,cAAcH,GAAGS,UAAS;QACxC,IAAIC,IAAIlB,YAAWO,wBAAA,IAACU;QAKpB,IAJS,IAALD,UACFE,EAAEC,qBACFJ,IAAII,sBAEFD,MAAMH,OAEA,IAALC,SACqB,MAAnBE,EAAEE,QAAQL,MAGf,OAAOE;AAEX;AACF;;OAEM,SAAUI,UAAUb,GAA0BO,KAAaO,OAAeN,QAAe;IAC7F,KAAKR,GACH,MAAM,IAAIe,MAAM;IAGlB,IAAIC,MAAG;IAMP,IAJS,KAALR,UACFQ,MAAMV,UAAUN,GAAGO,KAAG,GAAWC,SAG/BQ,KAAK;QACP,IAAS,KAALR,OACF,OAAO;QAEA,KAALA,UACFM,QAAQ,GAAGtB,YAAWO,wBAAA,IAACiB,MAAG,OAAWF;QAEvCG,qBAAAC,KAAAnB,wBAAA,IAAKiB,MAAG,KACRf,yBAAA,IAAAe,MAAG,GAAAC,qBAAAE,OAAgBL,MAAMM,SAAS;QAClC3B,aAAYM,wBAAA,IAACiB,MAAG,IAAQF,OAAOA,MAAMM;AACvC,WACK;QACH,IAAIC,MAAGJ,qBAAAK,QAAAvB,wBAAA,IAAuCC,IAAC,IAAqB,KAAZD,wBAAA,IAAAC,KAAU;QAClEC,yBAAA,IAAAD,IAAC,GAASqB,MAEVpB,yBAAA,IAAAF,wBAAA,IAAAC,IAAC,KAAQ,IAARD,wBAAA,IAAOC,IAACiB,qBAAAE,OAAqBZ,IAAIa,SAAS;QAC3CnB,yBAAA,IAAAF,wBAAA,IAAAC,IAAC,KAAQ,IAARD,wBAAA,IAAOC,KAAC,GAAAiB,qBAAAE,OAAuBL,MAAMM,SAAS;QAE/C3B,aAAYM,wBAAA,IAAAA,wBAAA,IAACC,IAAC,KAAQ,IAARD,wBAAA,IAAOC,KAAcO,KAAKA,IAAIa;QAC5C3B,aAAYM,wBAAA,IAAAA,wBAAA,IAACC,IAAC,KAAQ,IAARD,wBAAA,IAAOC,KAAC,IAAec,OAAOA,MAAMM;QAElDnB,yBAAA,IAAAD,GAACD,wBAAA,IAADC,KAAC;AACH;IAEA,OAAO;AACT;;OAEM,SAAUuB,WAAWC,KAA4BC,KAA4BjB;IACjF,KAAKgB,QAAQC,KACX,QAAQ;IAGV,IAAIC,IAAC;IAEL,MAAQA,IAAIvB,cAAcsB,KAAKC,MAAK;QAClC,IAAIC,MAAMd,UAAUW,KAAKhC,YAAWO,wBAAA,IAAC2B,KAAQlC,YAAWO,wBAAA,IAAC2B,IAAC,KAASlB;QACnE,IAAImB,MAAM,GACR,OAAOA;AAEX;IAEA,OAAO;AACT","ignoreList":[]}

package/dist/esm/util/avframe.d.ts

@@ -0,0 +1,14 @@
+import AVFrame, { AVFrameSideData, AVFrameSideDataType } from "../struct/avframe";
+export declare function createAVFrame(): pointer<AVFrame>;
+export declare function destroyAVFrame(frame: pointer<AVFrame>): void;
+export declare function freeSideData(ptr: pointer<pointer<AVFrameSideData>>): void;
+export declare function wipeSideData(frame: pointer<AVFrame>): void;
+export declare function getAVFrameSideData(frame: pointer<AVFrame>, type: AVFrameSideDataType): pointer<AVFrameSideData>;
+export declare function getAVFrameDefault(frame: pointer<AVFrame>): void;
+export declare function getVideoBuffer(frame: pointer<AVFrame>, algin?: int32): number;
+export declare function getAudioBuffer(frame: pointer<AVFrame>, algin?: int32): number;
+export declare function getBuffer(frame: pointer<AVFrame>, algin?: int32): number;
+export declare function refAVFrame(dst: pointer<AVFrame>, src: pointer<AVFrame>): number;
+export declare function unrefAVFrame(frame: pointer<AVFrame>): void;
+export declare function copyAVFrameProps(dst: pointer<AVFrame>, src: pointer<AVFrame>): number;
+export declare function cloneAVFrame(frame: pointer<AVFrame>): pointer<AVFrame>;