@libmedia/avutil 0.2.0

package/dist/esm/util/avframe.js

@@ -0,0 +1,218 @@
+import { memcpy as cheap__memcpy__158 } from "@libmedia/cheap/std/memory";
+
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__7 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { AVChannelLayout as cheap__AVChannelLayout__154 } from "../struct/audiosample";
+
+import cheap__structAccess__155 from "@libmedia/cheap/std/structAccess";
+
+import { Rational as cheap__Rational__232 } from "../struct/rational";
+
+import AVFrame, { AV_NUM_DATA_POINTERS } from "../struct/avframe";
+
+import { avFree, avFreep, avMalloc, avMallocz } from "./mem";
+
+import { memcpy, memset } from "@libmedia/cheap/std/memory";
+
+import { INT32_MAX, NOPTS_VALUE_BIGINT } from "../constant";
+
+import { avbufferAlloc, avbufferRef, avbufferReplace, avbufferUnref } from "./avbuffer";
+
+import { freeAVDict } from "./avdict";
+
+import { INVALID_ARGUMENT, NO_MEMORY } from "../error";
+
+import { getChannelLayoutNBChannels } from "./channel";
+
+import { sampleFormatGetLinesize, sampleFormatIsPlanar } from "./sample";
+
+import * as errorType from "../error";
+
+import { PixelFormatDescriptorsMap } from "../pixelFormatDescriptor";
+
+import * as stack from "@libmedia/cheap/stack";
+
+import { pixelFillLinesizes, pixelFillPlaneSizes, pixelFillPointer } from "./pixel";
+
+import alignFunc from "@libmedia/common/math/align";
+
+export function createAVFrame() {
+    const frame = avMallocz(320);
+    return getAVFrameDefault(frame), frame;
+}
+
+export function destroyAVFrame(frame) {
+    unrefAVFrame(frame), avFree(frame);
+}
+
+export function freeSideData(ptr) {
+    const sideData = cheap__CTypeEnumRead__0[20](ptr);
+    avbufferUnref(sideData + 16), freeAVDict(sideData + 12), avFreep(ptr);
+}
+
+export function wipeSideData(frame) {
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](frame + 200); i++) freeSideData(cheap__CTypeEnumRead__0[20](frame + 196) + 4 * i);
+    cheap__CTypeEnumWrite__7[15](frame + 200, 0), avFreep(frame + 196);
+}
+
+export function getAVFrameSideData(frame, type) {
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](frame + 200); i++) if (cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 196) + 4 * i)) === type) return cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 196) + 4 * i);
+    return 0;
+}
+
+export function getAVFrameDefault(frame) {
+    cheap__CTypeEnumRead__0[20](frame + 64) !== frame && avFreep(frame + 64), memset(frame, 0, 320), 
+    cheap__CTypeEnumWrite__7[17](frame + 104, NOPTS_VALUE_BIGINT), cheap__CTypeEnumWrite__7[17](frame + 112, NOPTS_VALUE_BIGINT), 
+    cheap__CTypeEnumWrite__7[17](frame + 232, NOPTS_VALUE_BIGINT), cheap__CTypeEnumWrite__7[17](frame + 240, NOPTS_VALUE_BIGINT), 
+    cheap__CTypeEnumWrite__7[15](frame + 256, -1), cheap__CTypeEnumWrite__7[15](frame + 84, 1), 
+    cheap__CTypeEnumWrite__7[15](frame + 92, 0), cheap__CTypeEnumWrite__7[15](frame + 96, 1), 
+    cheap__CTypeEnumWrite__7[15](frame + 80, -1), cheap__CTypeEnumWrite__7[20](frame + 64, frame), 
+    cheap__CTypeEnumWrite__7[15](frame + 212, 2), cheap__CTypeEnumWrite__7[15](frame + 216, 2), 
+    cheap__CTypeEnumWrite__7[15](frame + 220, 2), cheap__CTypeEnumWrite__7[15](frame + 208, 0), 
+    cheap__CTypeEnumWrite__7[15](frame + 224, 0), cheap__CTypeEnumWrite__7[15](frame + 204, 0);
+}
+
+export function getVideoBuffer(frame, algin = 0) {
+    if (!PixelFormatDescriptorsMap[cheap__CTypeEnumRead__0[15](frame + 80)]) return errorType.INVALID_ARGUMENT;
+    const linesizes = stack.malloc(16), sizes = stack.malloc(16), planePadding = Math.max(32, algin);
+    let ret = 0;
+    if (!cheap__CTypeEnumRead__0[15](frame + 32)) {
+        algin <= 0 && (algin = 32);
+        for (let i = 1; i < algin; i += i) {
+            if (ret = pixelFillLinesizes(frame + 32, cheap__CTypeEnumRead__0[15](frame + 80), alignFunc(cheap__CTypeEnumRead__0[15](frame + 68), i)), 
+            ret < 0) return defer(), ret;
+            if (!(cheap__CTypeEnumRead__0[15](frame + 32) & algin - 1)) break;
+        }
+        for (let i = 0; i < 4 && cheap__CTypeEnumRead__0[15](frame + 32 + 4 * i); i++) cheap__CTypeEnumWrite__7[15](frame + 32 + 4 * i, alignFunc(cheap__CTypeEnumRead__0[15](frame + 32 + 4 * i), algin));
+    }
+    for (let i = 0; i < 4; i++) cheap__CTypeEnumWrite__7[15](linesizes + 4 * i, cheap__CTypeEnumRead__0[15](frame + 32 + 4 * i));
+    const paddingHeight = alignFunc(cheap__CTypeEnumRead__0[15](frame + 72), 32);
+    if ((ret = pixelFillPlaneSizes(sizes, cheap__CTypeEnumRead__0[15](frame + 80), paddingHeight, linesizes)) < 0) return defer(), 
+    ret;
+    let totalSize = 4 * planePadding;
+    for (let i = 0; i < 4; i++) cheap__CTypeEnumRead__0[15](sizes + 4 * i) > INT32_MAX - totalSize && errorType.INVALID_ARGUMENT, 
+    totalSize += cheap__CTypeEnumRead__0[15](sizes + 4 * i);
+    if (cheap__CTypeEnumWrite__7[20](frame + 156, avbufferAlloc(totalSize)), !cheap__CTypeEnumRead__0[20](frame + 156)) return unrefAVFrame(frame), 
+    defer(), errorType.NO_MEMORY;
+    if ((ret = pixelFillPointer(frame, cheap__CTypeEnumRead__0[15](frame + 80), paddingHeight, cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 156) + 4), linesizes)) < 0) return unrefAVFrame(frame), 
+    defer(), ret;
+    for (let i = 1; i < 4; i++) cheap__CTypeEnumRead__0[20](frame + 4 * i) && cheap__CTypeEnumWrite__7[20](frame + 4 * i, cheap__CTypeEnumRead__0[20](frame + 4 * i) + i * planePadding);
+    return cheap__CTypeEnumWrite__7[20](frame + 64, frame), defer(), 0;
+    function defer() {
+        stack.free(16), stack.free(16);
+    }
+}
+
+export function getAudioBuffer(frame, algin) {
+    const planar = sampleFormatIsPlanar(cheap__CTypeEnumRead__0[15](frame + 80)), channels = cheap__CTypeEnumRead__0[15](frame + 292), planes = planar ? channels : 1;
+    let ret = 0;
+    if (!cheap__CTypeEnumRead__0[15](frame + 32)) {
+        if (ret = sampleFormatGetLinesize(cheap__CTypeEnumRead__0[15](frame + 80), channels, cheap__CTypeEnumRead__0[15](frame + 76), algin), 
+        ret < 0) return ret;
+        cheap__CTypeEnumWrite__7[15](frame + 32, ret);
+    }
+    if (planes > AV_NUM_DATA_POINTERS) {
+        if (cheap__CTypeEnumWrite__7[20](frame + 64, avMalloc(4 * planes)), cheap__CTypeEnumWrite__7[20](frame + 188, avMalloc(4 * planes)), 
+        !cheap__CTypeEnumRead__0[20](frame + 188) || !cheap__CTypeEnumRead__0[20](frame + 64)) return avFreep(frame + 64), 
+        avFreep(frame + 188), errorType.NO_MEMORY;
+        cheap__CTypeEnumWrite__7[15](frame + 192, planes - AV_NUM_DATA_POINTERS);
+    } else cheap__CTypeEnumWrite__7[20](frame + 64, frame);
+    for (let i = 0; i < Math.min(planes, AV_NUM_DATA_POINTERS); i++) {
+        if (cheap__CTypeEnumWrite__7[20](frame + 156 + 4 * i, avbufferAlloc(cheap__CTypeEnumRead__0[15](frame + 32))), 
+        !cheap__CTypeEnumRead__0[20](frame + 156 + 4 * i)) return unrefAVFrame(frame), errorType.NO_MEMORY;
+        cheap__CTypeEnumWrite__7[20](cheap__CTypeEnumRead__0[20](frame + 64) + 4 * i, cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 156 + 4 * i) + 4)), 
+        cheap__CTypeEnumWrite__7[20](frame + 4 * i, cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 156 + 4 * i) + 4));
+    }
+    for (let i = 0; i < planes - AV_NUM_DATA_POINTERS; i++) {
+        if (cheap__CTypeEnumWrite__7[20](cheap__CTypeEnumRead__0[20](frame + 188) + 4 * i, avbufferAlloc(cheap__CTypeEnumRead__0[15](frame + 32))), 
+        !cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 188) + 4 * i)) return unrefAVFrame(frame), 
+        errorType.NO_MEMORY;
+        cheap__CTypeEnumWrite__7[20](cheap__CTypeEnumRead__0[20](frame + 64) + (i + AV_NUM_DATA_POINTERS), cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](frame + 188) + 4 * i) + 4));
+    }
+}
+
+export function getBuffer(frame, algin) {
+    return cheap__CTypeEnumRead__0[15](frame + 80) < 0 ? INVALID_ARGUMENT : cheap__CTypeEnumRead__0[15](frame + 68) > 0 && cheap__CTypeEnumRead__0[15](frame + 72) > 0 ? getVideoBuffer(frame, algin) : cheap__CTypeEnumRead__0[15](frame + 76) > 0 && (cheap__CTypeEnumRead__0[10](frame + 296) || cheap__CTypeEnumRead__0[15](frame + 292) > 0) ? getAudioBuffer(frame, algin) : INVALID_ARGUMENT;
+}
+
+export function refAVFrame(dst, src) {
+    cheap__CTypeEnumWrite__7[15](dst + 80, cheap__CTypeEnumRead__0[15](src + 80)), cheap__CTypeEnumWrite__7[15](dst + 68, cheap__CTypeEnumRead__0[15](src + 68)), 
+    cheap__CTypeEnumWrite__7[15](dst + 72, cheap__CTypeEnumRead__0[15](src + 72)), cheap__memcpy__158(dst + 288, src + 288, 24), 
+    cheap__CTypeEnumWrite__7[15](dst + 76, cheap__CTypeEnumRead__0[15](src + 76));
+    let ret = copyAVFrameProps(dst, src);
+    if (ret < 0) return ret;
+    if (!cheap__CTypeEnumRead__0[20](src + 156)) {
+        for (let i = 0; i < 8; i++) {
+            if (!cheap__CTypeEnumRead__0[20](src + 4 * i) || !cheap__CTypeEnumRead__0[15](src + 32 + 4 * i)) continue;
+            let size = cheap__CTypeEnumRead__0[15](src + 32 + 4 * i);
+            if (cheap__CTypeEnumWrite__7[20](dst + 4 * i, avMalloc(size)), !cheap__CTypeEnumRead__0[20](dst + 4 * i)) return unrefAVFrame(dst), 
+            NO_MEMORY;
+            memcpy(cheap__CTypeEnumRead__0[20](dst + 4 * i), cheap__CTypeEnumRead__0[20](src + 4 * i), size);
+        }
+        return 0;
+    }
+    for (let i = 0; i < 8; i++) if (cheap__CTypeEnumRead__0[20](src + 156 + 4 * i) && (cheap__CTypeEnumWrite__7[20](dst + 156 + 4 * i, avbufferRef(cheap__CTypeEnumRead__0[20](src + 156 + 4 * i))), 
+    !cheap__CTypeEnumRead__0[20](dst + 156 + 4 * i))) return unrefAVFrame(dst), NO_MEMORY;
+    if (cheap__CTypeEnumRead__0[20](src + 188)) {
+        if (cheap__CTypeEnumWrite__7[20](dst + 188, avMallocz(4 * cheap__CTypeEnumRead__0[15](src + 192))), 
+        !cheap__CTypeEnumRead__0[20](dst + 188)) return unrefAVFrame(dst), NO_MEMORY;
+        cheap__CTypeEnumWrite__7[15](dst + 192, cheap__CTypeEnumRead__0[15](src + 192));
+        for (let i = 0; i < cheap__CTypeEnumRead__0[15](src + 192); i++) if (cheap__CTypeEnumWrite__7[20](cheap__CTypeEnumRead__0[20](dst + 188) + 4 * i, avbufferRef(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](src + 188) + 4 * i))), 
+        !cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst + 188) + 4 * i)) return unrefAVFrame(dst), 
+        NO_MEMORY;
+    }
+    if (cheap__CTypeEnumRead__0[20](src + 64) !== src) {
+        let ch = cheap__CTypeEnumRead__0[15](src + 292);
+        if (!ch) return unrefAVFrame(dst), INVALID_ARGUMENT;
+        if (cheap__CTypeEnumWrite__7[20](dst + 64, avMallocz(4 * ch)), !cheap__CTypeEnumRead__0[20](dst + 64)) return unrefAVFrame(dst), 
+        NO_MEMORY;
+        memcpy(cheap__CTypeEnumRead__0[20](dst + 64), cheap__CTypeEnumRead__0[20](src + 64), 4 * ch);
+    } else cheap__CTypeEnumWrite__7[20](dst + 64, dst);
+    return memcpy(dst, src, 32), memcpy(dst + 32, src + 32, 32), 0;
+}
+
+export function unrefAVFrame(frame) {
+    wipeSideData(frame);
+    for (let i = 0; i < 8; i++) avbufferUnref(frame + 156 + 4 * i);
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](frame + 192); i++) avbufferUnref(cheap__CTypeEnumRead__0[20](frame + 188) + 4 * i);
+    avFreep(frame + 188), freeAVDict(frame + 248), avbufferUnref(frame + 260), avbufferUnref(frame + 264), 
+    avbufferUnref(frame + 284), getAVFrameDefault(frame);
+}
+
+export function copyAVFrameProps(dst, src) {
+    cheap__CTypeEnumWrite__7[15](dst + 84, cheap__CTypeEnumRead__0[15](src + 84)), cheap__CTypeEnumWrite__7[15](dst + 88, cheap__CTypeEnumRead__0[15](src + 88)), 
+    cheap__memcpy__158(dst + 92, src + 92, 8), cheap__CTypeEnumWrite__7[15](dst + 268, cheap__CTypeEnumRead__0[15](src + 268)), 
+    cheap__CTypeEnumWrite__7[15](dst + 272, cheap__CTypeEnumRead__0[15](src + 272)), 
+    cheap__CTypeEnumWrite__7[15](dst + 276, cheap__CTypeEnumRead__0[15](src + 276)), 
+    cheap__CTypeEnumWrite__7[15](dst + 280, cheap__CTypeEnumRead__0[15](src + 280)), 
+    cheap__CTypeEnumWrite__7[17](dst + 104, cheap__CTypeEnumRead__0[17](src + 104)), 
+    cheap__CTypeEnumWrite__7[15](dst + 136, cheap__CTypeEnumRead__0[15](src + 136)), 
+    cheap__CTypeEnumWrite__7[15](dst + 140, cheap__CTypeEnumRead__0[15](src + 140)), 
+    cheap__CTypeEnumWrite__7[15](dst + 144, cheap__CTypeEnumRead__0[15](src + 144)), 
+    cheap__CTypeEnumWrite__7[15](dst + 148, cheap__CTypeEnumRead__0[15](src + 148)), 
+    cheap__CTypeEnumWrite__7[15](dst + 152, cheap__CTypeEnumRead__0[15](src + 152)), 
+    cheap__CTypeEnumWrite__7[20](dst + 132, cheap__CTypeEnumRead__0[20](src + 132)), 
+    cheap__CTypeEnumWrite__7[17](dst + 112, cheap__CTypeEnumRead__0[17](src + 112)), 
+    cheap__CTypeEnumWrite__7[17](dst + 240, cheap__CTypeEnumRead__0[17](src + 240)), 
+    cheap__CTypeEnumWrite__7[15](dst + 256, cheap__CTypeEnumRead__0[15](src + 256)), 
+    cheap__CTypeEnumWrite__7[15](dst + 128, cheap__CTypeEnumRead__0[15](src + 128)), 
+    cheap__CTypeEnumWrite__7[17](dst + 232, cheap__CTypeEnumRead__0[17](src + 232)), 
+    cheap__CTypeEnumWrite__7[15](dst + 204, cheap__CTypeEnumRead__0[15](src + 204)), 
+    cheap__CTypeEnumWrite__7[15](dst + 252, cheap__CTypeEnumRead__0[15](src + 252)), 
+    cheap__CTypeEnumWrite__7[15](dst + 212, cheap__CTypeEnumRead__0[15](src + 212)), 
+    cheap__CTypeEnumWrite__7[15](dst + 216, cheap__CTypeEnumRead__0[15](src + 216)), 
+    cheap__CTypeEnumWrite__7[15](dst + 220, cheap__CTypeEnumRead__0[15](src + 220)), 
+    cheap__CTypeEnumWrite__7[15](dst + 208, cheap__CTypeEnumRead__0[15](src + 208)), 
+    cheap__CTypeEnumWrite__7[15](dst + 224, cheap__CTypeEnumRead__0[15](src + 224));
+    let ret = avbufferReplace(dst + 264, cheap__CTypeEnumRead__0[20](src + 264));
+    return ret |= avbufferReplace(dst + 284, cheap__CTypeEnumRead__0[20](src + 284)), 
+    ret;
+}
+
+export function cloneAVFrame(frame) {
+    const ret = createAVFrame();
+    return refAVFrame(ret, frame), ret;
+}
+//# sourceMappingURL=avframe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["AVFrame","AV_NUM_DATA_POINTERS","avFree","avFreep","avMalloc","avMallocz","memcpy","memset","INT32_MAX","NOPTS_VALUE_BIGINT","avbufferAlloc","avbufferRef","avbufferReplace","avbufferUnref","freeAVDict","INVALID_ARGUMENT","NO_MEMORY","getChannelLayoutNBChannels","sampleFormatGetLinesize","sampleFormatIsPlanar","errorType","PixelFormatDescriptorsMap","stack","pixelFillLinesizes","pixelFillPlaneSizes","pixelFillPointer","alignFunc","createAVFrame","frame","getAVFrameDefault","destroyAVFrame","unrefAVFrame","freeSideData","ptr","sideData","cheap__CTypeEnumRead__0","wipeSideData","i","cheap__CTypeEnumWrite__7","getAVFrameSideData","type","getVideoBuffer","algin","linesizes","malloc","sizes","planePadding","Math","max","ret","defer","paddingHeight","totalSize","free","getAudioBuffer","planar","channels","planes","min","getBuffer","refAVFrame","dst","src","cheap__memcpy__158","copyAVFrameProps","size","ch","cloneAVFrame"],"sources":["../../../util/avframe.ts"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,22 @@
+import AVPacket, { AVPacketSideData } from "../struct/avpacket";
+import { AVPacketSideDataType } from "../codec";
+import SafeUint8Array from "@libmedia/cheap/std/buffer/SafeUint8Array";
+export declare function getAVPacketData(avpacket: pointer<AVPacket>): Uint8Array;
+export declare function getAVPacketData(avpacket: pointer<AVPacket>, safe: boolean): SafeUint8Array;
+export declare function initAVPacketData(avpacket: pointer<AVPacket>, length: size): Uint8Array;
+export declare function getAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType): pointer<AVPacketSideData>;
+export declare function hasAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType): boolean;
+export declare function addSideData(psd: pointer<pointer<AVPacketSideData>>, pnbSd: pointer<int32>, type: AVPacketSideDataType, data: pointer<void>, length: size): pointer<AVPacketSideData>;
+export declare function newSideData(psd: pointer<pointer<AVPacketSideData>>, pnbSd: pointer<int32>, type: AVPacketSideDataType, size: size): pointer<AVPacketSideData>;
+export declare function addAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType, data: pointer<void>, length: size): void;
+export declare function deleteAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType): void;
+export declare function createAVPacket(): pointer<AVPacket>;
+export declare function destroyAVPacket(avpacket: pointer<AVPacket>): void;
+export declare function freeAVPacketSideData(pSideData: pointer<pointer<AVPacketSideData>>, pnbSideData: pointer<int32>): void;
+export declare function getAVPacketDefault(avpacket: pointer<AVPacket>): void;
+export declare function copyAVPacketSideData(dst: pointer<AVPacket>, src: pointer<AVPacket>): void;
+export declare function copyAVPacketProps(dst: pointer<AVPacket>, src: pointer<AVPacket>): number;
+export declare function refAVPacket(dst: pointer<AVPacket>, src: pointer<AVPacket>): number;
+export declare function unrefAVPacket(avpacket: pointer<AVPacket>): void;
+export declare function copyAVPacketData(dst: pointer<AVPacket>, src: pointer<AVPacket>): void;
+export declare function addAVPacketData(avpacket: pointer<AVPacket>, data: pointer<uint8>, size: size): void;

package/dist/esm/util/avpacket.js

@@ -0,0 +1,161 @@
+import { memcpy as cheap__memcpy__31 } from "@libmedia/cheap/std/memory";
+
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__5 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { AVPacketSideData as cheap__AVPacketSideData__14 } from "../struct/avpacket";
+
+import cheap__structAccess__15 from "@libmedia/cheap/std/structAccess";
+
+import AVPacket, { AVPacketSideData } from "../struct/avpacket";
+
+import { memcpy, memset, mapUint8Array, mapSafeUint8Array } from "@libmedia/cheap/std/memory";
+
+import { avFree, avFreep, avMalloc, avMallocz } from "./mem";
+
+import { AV_TIME_BASE, NOPTS_VALUE, NOPTS_VALUE_BIGINT } from "../constant";
+
+import { avbufferCreate, avbufferRealloc, avbufferRef, avbufferReplace, avbufferUnref } from "./avbuffer";
+
+export function getAVPacketData(avpacket, safe) {
+    return safe ? mapSafeUint8Array(cheap__CTypeEnumRead__0[20](avpacket + 24), cheap__CTypeEnumRead__0[15](avpacket + 28)) : mapUint8Array(cheap__CTypeEnumRead__0[20](avpacket + 24), cheap__CTypeEnumRead__0[15](avpacket + 28));
+}
+
+export function initAVPacketData(avpacket, length) {
+    return cheap__CTypeEnumWrite__5[20](avpacket + 24, avMalloc(length)), cheap__CTypeEnumWrite__5[15](avpacket + 28, length), 
+    mapUint8Array(cheap__CTypeEnumRead__0[20](avpacket + 24), cheap__CTypeEnumRead__0[15](avpacket + 28));
+}
+
+export function getAVPacketSideData(avpacket, type) {
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](avpacket + 44); i++) if (cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i + 8) === type) return cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i;
+    return 0;
+}
+
+export function hasAVPacketSideData(avpacket, type) {
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](avpacket + 44); i++) if (cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i + 8) === type) return !0;
+    return !1;
+}
+
+export function addSideData(psd, pnbSd, type, data, length) {
+    const sideDataElems = cheap__CTypeEnumRead__0[15](pnbSd), sideData = cheap__CTypeEnumRead__0[20](psd);
+    for (let i = 0; i < sideDataElems; i++) if (cheap__CTypeEnumRead__0[15](sideData + 12 * i + 8) === type) return avFree(cheap__CTypeEnumRead__0[20](sideData + 12 * i)), 
+    cheap__CTypeEnumWrite__5[20](sideData + 12 * i, data), void cheap__CTypeEnumWrite__5[15](sideData + 12 * i + 4, length);
+    const newSideData = avMallocz(12 * (sideDataElems + 1));
+    if (sideDataElems) for (let i = 0; i < sideDataElems; i++) cheap__memcpy__31(newSideData + 12 * i, sideData + 12 * i, 12);
+    const ele = newSideData + 12 * sideDataElems;
+    return cheap__CTypeEnumWrite__5[20](ele, data), cheap__CTypeEnumWrite__5[15](ele + 8, type), 
+    cheap__CTypeEnumWrite__5[15](ele + 4, length), sideData && avFree(sideData), cheap__CTypeEnumWrite__5[20](psd, newSideData), 
+    cheap__CTypeEnumWrite__5[15](pnbSd, sideDataElems + 1), ele;
+}
+
+export function newSideData(psd, pnbSd, type, size) {
+    const data = avMalloc(size + 64);
+    return memset(data + size, 0, 64), addSideData(psd, pnbSd, type, data, size);
+}
+
+export function addAVPacketSideData(avpacket, type, data, length) {
+    addSideData(avpacket + 40, avpacket + 44, type, data, length);
+}
+
+export function deleteAVPacketSideData(avpacket, type) {
+    let index = -1;
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](avpacket + 44); i++) if (cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i + 8) === type) {
+        index = i;
+        break;
+    }
+    if (index > -1) if (1 === cheap__CTypeEnumRead__0[15](avpacket + 44)) avFree(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](avpacket + 40))), 
+    avFree(cheap__CTypeEnumRead__0[20](avpacket + 40)), cheap__CTypeEnumWrite__5[20](avpacket + 40, 0), 
+    cheap__CTypeEnumWrite__5[15](avpacket + 44, 0); else {
+        const len = 12 * (cheap__CTypeEnumRead__0[15](avpacket + 44) - 1), sideData = avMallocz(len);
+        for (let i = 0; i < cheap__CTypeEnumRead__0[15](avpacket + 44); i++) i !== index ? cheap__memcpy__31(sideData + 12 * i, cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i, 12) : avFree(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i));
+        avFree(cheap__CTypeEnumRead__0[20](avpacket + 40)), cheap__CTypeEnumWrite__5[20](avpacket + 40, sideData), 
+        cheap__CTypeEnumWrite__5[15](avpacket + 44, cheap__CTypeEnumRead__0[15](avpacket + 44) - 1);
+    }
+}
+
+export function createAVPacket() {
+    const avpacket = avMallocz(88);
+    return getAVPacketDefault(avpacket), avpacket;
+}
+
+export function destroyAVPacket(avpacket) {
+    unrefAVPacket(avpacket), avFree(avpacket);
+}
+
+export function freeAVPacketSideData(pSideData, pnbSideData) {
+    const sideData = cheap__CTypeEnumRead__0[20](pSideData), nbSideData = cheap__CTypeEnumRead__0[15](pnbSideData);
+    if (sideData) {
+        for (let i = 0; i < nbSideData; i++) avFree(cheap__CTypeEnumRead__0[20](sideData + 12 * i));
+        avFreep(pSideData), cheap__CTypeEnumWrite__5[15](pnbSideData, 0);
+    }
+}
+
+export function getAVPacketDefault(avpacket) {
+    cheap__CTypeEnumWrite__5[20](avpacket + 24, 0), cheap__CTypeEnumWrite__5[15](avpacket + 28, 0), 
+    cheap__CTypeEnumWrite__5[20](avpacket + 40, 0), cheap__CTypeEnumWrite__5[15](avpacket + 44, 0), 
+    cheap__CTypeEnumWrite__5[15](avpacket + 32, NOPTS_VALUE), cheap__CTypeEnumWrite__5[17](avpacket + 56, NOPTS_VALUE_BIGINT), 
+    cheap__CTypeEnumWrite__5[17](avpacket + 48, NOPTS_VALUE_BIGINT), cheap__CTypeEnumWrite__5[15](avpacket + 36, 0), 
+    cheap__CTypeEnumWrite__5[17](avpacket + 16, NOPTS_VALUE_BIGINT), cheap__CTypeEnumWrite__5[17](avpacket + 8, NOPTS_VALUE_BIGINT), 
+    cheap__CTypeEnumWrite__5[15](avpacket + 76, AV_TIME_BASE), cheap__CTypeEnumWrite__5[15](avpacket + 72, 1), 
+    cheap__CTypeEnumWrite__5[15](avpacket + 80, 0), cheap__CTypeEnumWrite__5[20](avpacket, 0);
+}
+
+export function copyAVPacketSideData(dst, src) {
+    if (freeAVPacketSideData(dst + 40, dst + 44), cheap__CTypeEnumRead__0[15](src + 44)) {
+        let size = 12;
+        cheap__CTypeEnumWrite__5[20](dst + 40, avMallocz(size * cheap__CTypeEnumRead__0[15](src + 44)));
+        for (let i = 0; i < cheap__CTypeEnumRead__0[15](src + 44); i++) cheap__CTypeEnumWrite__5[15](cheap__CTypeEnumRead__0[20](dst + 40) + 12 * i + 4, cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](src + 40) + 12 * i + 4)), 
+        cheap__CTypeEnumWrite__5[15](cheap__CTypeEnumRead__0[20](dst + 40) + 12 * i + 8, cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](src + 40) + 12 * i + 8)), 
+        cheap__CTypeEnumWrite__5[20](cheap__CTypeEnumRead__0[20](dst + 40) + 12 * i, avMalloc(cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](src + 40) + 12 * i + 4))), 
+        memcpy(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst + 40) + 12 * i), cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](src + 40) + 12 * i), cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](src + 40) + 12 * i + 4));
+        cheap__CTypeEnumWrite__5[15](dst + 44, cheap__CTypeEnumRead__0[15](src + 44));
+    }
+}
+
+export function copyAVPacketProps(dst, src) {
+    return cheap__CTypeEnumWrite__5[15](dst + 32, cheap__CTypeEnumRead__0[15](src + 32)), 
+    cheap__CTypeEnumWrite__5[17](dst + 56, cheap__CTypeEnumRead__0[17](src + 56)), cheap__CTypeEnumWrite__5[17](dst + 48, cheap__CTypeEnumRead__0[17](src + 48)), 
+    cheap__CTypeEnumWrite__5[15](dst + 36, cheap__CTypeEnumRead__0[15](src + 36)), cheap__CTypeEnumWrite__5[17](dst + 16, cheap__CTypeEnumRead__0[17](src + 16)), 
+    cheap__CTypeEnumWrite__5[17](dst + 8, cheap__CTypeEnumRead__0[17](src + 8)), cheap__CTypeEnumWrite__5[20](dst + 64, cheap__CTypeEnumRead__0[20](src + 64)), 
+    cheap__CTypeEnumWrite__5[15](dst + 76, cheap__CTypeEnumRead__0[15](src + 76)), cheap__CTypeEnumWrite__5[15](dst + 72, cheap__CTypeEnumRead__0[15](src + 72)), 
+    cheap__CTypeEnumWrite__5[15](dst + 80, cheap__CTypeEnumRead__0[15](src + 80)), cheap__CTypeEnumWrite__5[20](dst + 68, 0), 
+    avbufferReplace(dst + 68, cheap__CTypeEnumRead__0[20](src + 68)), copyAVPacketSideData(dst, src), 
+    0;
+}
+
+function allocAVPacket(buf, size) {
+    return avbufferRealloc(buf, size + 64), memset(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](buf) + 4) + size, 0, 64), 
+    0;
+}
+
+export function refAVPacket(dst, src) {
+    return cheap__CTypeEnumRead__0[20](dst) && avbufferUnref(dst), cheap__CTypeEnumWrite__5[20](dst, 0), 
+    copyAVPacketProps(dst, src), !cheap__CTypeEnumRead__0[20](src) && cheap__CTypeEnumRead__0[15](src + 28) ? (allocAVPacket(dst, cheap__CTypeEnumRead__0[15](src + 28)), 
+    cheap__CTypeEnumRead__0[15](src + 28) && memcpy(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst) + 4), cheap__CTypeEnumRead__0[20](src + 24), cheap__CTypeEnumRead__0[15](src + 28)), 
+    cheap__CTypeEnumWrite__5[20](dst + 24, cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst) + 4))) : cheap__CTypeEnumRead__0[20](src) && (cheap__CTypeEnumWrite__5[20](dst, avbufferRef(cheap__CTypeEnumRead__0[20](src))), 
+    cheap__CTypeEnumWrite__5[20](dst + 24, cheap__CTypeEnumRead__0[20](src + 24))), 
+    cheap__CTypeEnumWrite__5[15](dst + 28, cheap__CTypeEnumRead__0[15](src + 28)), 0;
+}
+
+export function unrefAVPacket(avpacket) {
+    freeAVPacketSideData(avpacket + 40, avpacket + 44), avbufferUnref(avpacket + 68), 
+    cheap__CTypeEnumRead__0[20](avpacket) ? avbufferUnref(avpacket) : cheap__CTypeEnumRead__0[20](avpacket + 24) && avFree(cheap__CTypeEnumRead__0[20](avpacket + 24)), 
+    getAVPacketDefault(avpacket);
+}
+
+export function copyAVPacketData(dst, src) {
+    cheap__CTypeEnumRead__0[20](dst) && avbufferUnref(dst), cheap__CTypeEnumWrite__5[20](dst, 0), 
+    !cheap__CTypeEnumRead__0[20](src) && cheap__CTypeEnumRead__0[15](src + 28) ? (allocAVPacket(dst, cheap__CTypeEnumRead__0[15](src + 28)), 
+    cheap__CTypeEnumRead__0[15](src + 28) && memcpy(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst) + 4), cheap__CTypeEnumRead__0[20](src + 24), cheap__CTypeEnumRead__0[15](src + 28)), 
+    cheap__CTypeEnumWrite__5[20](dst + 24, cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](dst) + 4))) : cheap__CTypeEnumRead__0[20](src) && (cheap__CTypeEnumWrite__5[20](dst, avbufferRef(cheap__CTypeEnumRead__0[20](src))), 
+    cheap__CTypeEnumWrite__5[20](dst + 24, cheap__CTypeEnumRead__0[20](src + 24))), 
+    cheap__CTypeEnumWrite__5[15](dst + 28, cheap__CTypeEnumRead__0[15](src + 28));
+}
+
+export function addAVPacketData(avpacket, data, size) {
+    cheap__CTypeEnumRead__0[20](avpacket) ? avbufferUnref(avpacket) : cheap__CTypeEnumRead__0[20](avpacket + 24) && avFree(cheap__CTypeEnumRead__0[20](avpacket + 24)), 
+    cheap__CTypeEnumWrite__5[20](avpacket, avbufferCreate(data, size + 64)), cheap__CTypeEnumWrite__5[20](avpacket + 24, data), 
+    cheap__CTypeEnumWrite__5[15](avpacket + 28, size);
+}
+//# sourceMappingURL=avpacket.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["AVPacket","AVPacketSideData","memcpy","memset","mapUint8Array","mapSafeUint8Array","avFree","avFreep","avMalloc","avMallocz","AV_TIME_BASE","NOPTS_VALUE","NOPTS_VALUE_BIGINT","avbufferCreate","avbufferRealloc","avbufferRef","avbufferReplace","avbufferUnref","getAVPacketData","avpacket","safe","cheap__CTypeEnumRead__0","initAVPacketData","length","cheap__CTypeEnumWrite__5","getAVPacketSideData","type","i","hasAVPacketSideData","addSideData","psd","pnbSd","data","sideDataElems","sideData","newSideData","cheap__memcpy__31","ele","size","addAVPacketSideData","deleteAVPacketSideData","index","len","createAVPacket","getAVPacketDefault","destroyAVPacket","unrefAVPacket","freeAVPacketSideData","pSideData","pnbSideData","nbSideData","copyAVPacketSideData","dst","src","copyAVPacketProps","allocAVPacket","buf","refAVPacket","copyAVPacketData","addAVPacketData"],"sources":["../../../util/avpacket.ts"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,4 @@
+import { AVChannelLayout } from "../struct/audiosample";
+export declare function getChannelLayoutNBChannels(layout: uint64): number;
+export declare function unInitChannelLayout(channelLayout: pointer<AVChannelLayout>): void;
+export declare function setChannelLayoutFromMask(channelLayout: pointer<AVChannelLayout>, mask: int32): 0 | -3;

package/dist/esm/util/channel.js

@@ -0,0 +1,25 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__3 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { popCount64 } from "./common";
+
+import { avFreep } from "./mem";
+
+import { memset } from "@libmedia/cheap/std/memory";
+
+import * as error from "../error";
+
+export function getChannelLayoutNBChannels(layout) {
+    return popCount64(layout);
+}
+
+export function unInitChannelLayout(channelLayout) {
+    2 == cheap__CTypeEnumRead__0[15](channelLayout) && avFreep(channelLayout + 8), memset(channelLayout, 0, 24);
+}
+
+export function setChannelLayoutFromMask(channelLayout, mask) {
+    return mask ? (cheap__CTypeEnumWrite__3[15](channelLayout, 1), cheap__CTypeEnumWrite__3[15](channelLayout + 4, popCount64(BigInt(mask >>> 0))), 
+    cheap__CTypeEnumWrite__3[10](channelLayout + 8, BigInt(mask >>> 0)), 0) : error.INVALID_ARGUMENT;
+}
+//# sourceMappingURL=channel.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["popCount64","avFreep","memset","error","getChannelLayoutNBChannels","layout","unInitChannelLayout","channelLayout","cheap__CTypeEnumRead__0","setChannelLayoutFromMask","mask","cheap__CTypeEnumWrite__3","BigInt","INVALID_ARGUMENT"],"sources":["../../../util/channel.ts"],"mappings":";;;;SA0BSA,kBAAY;;SAEZC,eAAS;;SACTC,cAAQ;;YACLC,WAAK;;OAEX,SAAUC,2BAA2BC;IACzC,OAAOL,WAAWK;AACpB;;OAEM,SAAUC,oBAAoBC;IACjB,KAAbC,wBAAA,IAAAD,kBACFN,QAAkBM,gBAAa,IAEjCL,OAAOK,eAAe,GAAC;AACzB;;OAEM,SAAUE,yBAAyBF,eAAyCG;IAChF,OAAKA,QAGLC,yBAAA,IAAAJ,eAAa,IACbI,yBAAA,IAAAJ,gBAAa,GAAcP,WAAUY,OAAqBF,SAAI;IAC9DC,yBAAA,IAAAJ,gBAAa,GAAAK,OAA8BF,SAAI,KACxC,KALEP,MAAMU;AAMjB","ignoreList":[]}

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

@@ -0,0 +1,4 @@
+import AVCodecParameters from "../struct/avcodecparameters";
+export declare function copyCodecParameters(dst: pointer<AVCodecParameters>, src: pointer<AVCodecParameters>): void;
+export declare function resetCodecParameters(par: pointer<AVCodecParameters>): void;
+export declare function freeCodecParameters(par: pointer<AVCodecParameters>): void;

package/dist/esm/util/codecparameters.js

@@ -0,0 +1,73 @@
+import { memcpy as cheap__memcpy__78 } from "@libmedia/cheap/std/memory";
+
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__2 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { AVChannelLayout as cheap__AVChannelLayout__74 } from "../struct/audiosample";
+
+import cheap__structAccess__75 from "@libmedia/cheap/std/structAccess";
+
+import { Rational as cheap__Rational__97 } from "../struct/rational";
+
+import { memcpy, memset } from "@libmedia/cheap/std/memory";
+
+import { avFree, avFreep, avMalloc, avMallocz } from "./mem";
+
+import { unInitChannelLayout } from "./channel";
+
+import { freeAVPacketSideData } from "./avpacket";
+
+import { NOPTS_VALUE } from "../constant";
+
+import { AVPacketSideData } from "../struct/avpacket";
+
+export function copyCodecParameters(dst, src) {
+    cheap__CTypeEnumWrite__2[15](dst, cheap__CTypeEnumRead__0[15](src)), cheap__CTypeEnumWrite__2[15](dst + 4, cheap__CTypeEnumRead__0[15](src + 4)), 
+    cheap__CTypeEnumWrite__2[8](dst + 8, cheap__CTypeEnumRead__0[8](src + 8)), cheap__CTypeEnumWrite__2[15](dst + 28, cheap__CTypeEnumRead__0[15](src + 28)), 
+    cheap__CTypeEnumWrite__2[17](dst + 32, cheap__CTypeEnumRead__0[17](src + 32)), cheap__CTypeEnumWrite__2[15](dst + 40, cheap__CTypeEnumRead__0[15](src + 40)), 
+    cheap__CTypeEnumWrite__2[15](dst + 44, cheap__CTypeEnumRead__0[15](src + 44)), cheap__CTypeEnumWrite__2[15](dst + 48, cheap__CTypeEnumRead__0[15](src + 48)), 
+    cheap__CTypeEnumWrite__2[15](dst + 52, cheap__CTypeEnumRead__0[15](src + 52)), cheap__CTypeEnumWrite__2[15](dst + 56, cheap__CTypeEnumRead__0[15](src + 56)), 
+    cheap__CTypeEnumWrite__2[15](dst + 60, cheap__CTypeEnumRead__0[15](src + 60)), cheap__CTypeEnumWrite__2[15](dst + 68, cheap__CTypeEnumRead__0[15](src + 68)), 
+    cheap__CTypeEnumWrite__2[15](dst + 64, cheap__CTypeEnumRead__0[15](src + 64)), cheap__CTypeEnumWrite__2[15](dst + 80, cheap__CTypeEnumRead__0[15](src + 80)), 
+    cheap__CTypeEnumWrite__2[15](dst + 84, cheap__CTypeEnumRead__0[15](src + 84)), cheap__CTypeEnumWrite__2[15](dst + 88, cheap__CTypeEnumRead__0[15](src + 88)), 
+    cheap__CTypeEnumWrite__2[15](dst + 92, cheap__CTypeEnumRead__0[15](src + 92)), cheap__CTypeEnumWrite__2[15](dst + 96, cheap__CTypeEnumRead__0[15](src + 96)), 
+    cheap__CTypeEnumWrite__2[15](dst + 100, cheap__CTypeEnumRead__0[15](src + 100)), 
+    cheap__CTypeEnumWrite__2[15](dst + 104, cheap__CTypeEnumRead__0[15](src + 104)), 
+    cheap__memcpy__78(dst + 112, src + 112, 24), cheap__CTypeEnumWrite__2[15](dst + 136, cheap__CTypeEnumRead__0[15](src + 136)), 
+    cheap__CTypeEnumWrite__2[15](dst + 140, cheap__CTypeEnumRead__0[15](src + 140)), 
+    cheap__CTypeEnumWrite__2[15](dst + 144, cheap__CTypeEnumRead__0[15](src + 144)), 
+    cheap__CTypeEnumWrite__2[15](dst + 148, cheap__CTypeEnumRead__0[15](src + 148)), 
+    cheap__CTypeEnumWrite__2[15](dst + 152, cheap__CTypeEnumRead__0[15](src + 152)), 
+    cheap__CTypeEnumWrite__2[15](dst + 156, cheap__CTypeEnumRead__0[15](src + 156)), 
+    cheap__memcpy__78(dst + 72, src + 72, 8), cheap__CTypeEnumRead__0[20](src + 12) && (cheap__CTypeEnumRead__0[20](dst + 12) && avFree(cheap__CTypeEnumRead__0[20](dst + 12)), 
+    cheap__CTypeEnumWrite__2[20](dst + 12, avMalloc(cheap__CTypeEnumRead__0[15](src + 16))), 
+    cheap__CTypeEnumWrite__2[15](dst + 16, cheap__CTypeEnumRead__0[15](src + 16)), memcpy(cheap__CTypeEnumRead__0[20](dst + 12), cheap__CTypeEnumRead__0[20](src + 12), cheap__CTypeEnumRead__0[15](src + 16))), 
+    cheap__CTypeEnumRead__0[20](src + 20) && function(pDst, pnbDst, src, nbSrc) {
+        if (!src) return;
+        const dst = avMallocz(12 * nbSrc);
+        for (let i = 0; i < nbSrc; i++) cheap__CTypeEnumWrite__2[15](dst + 12 * i + 8, cheap__CTypeEnumRead__0[15](src + 12 * i + 8)), 
+        cheap__CTypeEnumWrite__2[15](dst + 12 * i + 4, cheap__CTypeEnumRead__0[15](src + 12 * i + 4)), 
+        cheap__CTypeEnumWrite__2[20](dst + 12 * i, avMalloc(cheap__CTypeEnumRead__0[15](src + 12 * i + 4))), 
+        memcpy(dst + 12 * i, src + 12 * i, cheap__CTypeEnumRead__0[15](src + 12 * i + 4));
+        cheap__CTypeEnumWrite__2[15](pnbDst, nbSrc), cheap__CTypeEnumWrite__2[20](pDst, dst);
+    }(dst + 20, dst + 24, cheap__CTypeEnumRead__0[20](src + 20), cheap__CTypeEnumRead__0[15](src + 24));
+}
+
+export function resetCodecParameters(par) {
+    cheap__CTypeEnumRead__0[20](par + 12) && avFreep(par + 12), unInitChannelLayout(par + 112), 
+    freeAVPacketSideData(par + 20, par + 24), memset(par, 0, 168), cheap__CTypeEnumWrite__2[15](par, -1), 
+    cheap__CTypeEnumWrite__2[15](par + 4, 0), cheap__CTypeEnumWrite__2[15](par + 28, -1), 
+    cheap__CTypeEnumWrite__2[15](par + 112, 0), cheap__CTypeEnumWrite__2[15](par + 80, 0), 
+    cheap__CTypeEnumWrite__2[15](par + 84, 0), cheap__CTypeEnumWrite__2[15](par + 88, 2), 
+    cheap__CTypeEnumWrite__2[15](par + 92, 2), cheap__CTypeEnumWrite__2[15](par + 96, 2), 
+    cheap__CTypeEnumWrite__2[15](par + 100, 0), cheap__CTypeEnumWrite__2[15](par + 64, 0), 
+    cheap__CTypeEnumWrite__2[15](par + 68, 1), cheap__CTypeEnumWrite__2[15](par + 72, 0), 
+    cheap__CTypeEnumWrite__2[15](par + 72, 1), cheap__CTypeEnumWrite__2[15](par + 48, NOPTS_VALUE), 
+    cheap__CTypeEnumWrite__2[15](par + 52, NOPTS_VALUE);
+}
+
+export function freeCodecParameters(par) {
+    par && (resetCodecParameters(par), avFree(par));
+}
+//# sourceMappingURL=codecparameters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["memcpy","memset","avFree","avFreep","avMalloc","avMallocz","unInitChannelLayout","freeAVPacketSideData","NOPTS_VALUE","AVPacketSideData","copyCodecParameters","dst","src","cheap__CTypeEnumWrite__2","cheap__CTypeEnumRead__0","cheap__memcpy__78","pDst","pnbDst","nbSrc","i","copyCodecParametersSideData","resetCodecParameters","par","freeCodecParameters"],"sources":["../../../util/codecparameters.ts"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,3 @@
+export declare function popCount(x: uint32): number;
+export declare function popCount64(x: uint64): number;
+export declare function milliSecond2Second(time: int64): number;

package/dist/esm/util/common.js

@@ -0,0 +1,14 @@
+export function popCount(x) {
+    return x = (x = (858993459 & (x -= x >> 1 & 1431655765)) + (x >> 2 & 858993459)) + (x >> 4) & 252645135, 
+    (x += x >> 8) + (x >> 16) & 63;
+}
+
+export function popCount64(x) {
+    return popCount(Number(BigInt.asUintN(32, x))) + popCount(Number(BigInt.asUintN(32, x >> BigInt(32))));
+}
+
+export function milliSecond2Second(time) {
+    const integer = time / BigInt(1e3), decimal = time - integer * BigInt(1e3);
+    return Number(integer) + Number(decimal) / 1e3;
+}
+//# sourceMappingURL=common.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["popCount","x","popCount64","Number","BigInt","asUintN","milliSecond2Second","time","integer","decimal"],"sources":["../../../util/common.ts"],"mappings":"OAyBM,SAAUA,SAASC;IAKvB,OAFAA,KADAA,KAAS,aADTA,KAAMA,KAAK,IAAK,gBACSA,KAAK,IAAK,eACzBA,KAAK,KAAM;KACrBA,KAAKA,KAAK,MACGA,KAAK,MAAO;AAC3B;;OAEM,SAAUC,WAAWD;IACzB,OAAOD,SAAQG,OAAAC,OAAAC,QAAA,IAAqBJ,OAAMD,SAAQG,OAAAC,OAAAC,QAAA,IAAqBJ,KAACG,OAAA;AAC1E;;OAEM,SAAUE,mBAAmBC;IACjC,MAAMC,UAAUD,OAAIH,OAAA,MACdK,UAAUF,OAAOC,UAAOJ,OAAA;IAC9B,OAAOD,OAAOK,WAAWL,OAAOM,WAAW;AAC7C","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare function random(buffer: Uint8Array): void;

package/dist/esm/util/crypto.js

@@ -0,0 +1,4 @@
+export function random(buffer) {
+    crypto.getRandomValues(buffer);
+}
+//# sourceMappingURL=crypto.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["random","buffer","crypto","getRandomValues"],"sources":["../../../util/crypto.ts"],"mappings":"OAyBM,SAAUA,OAAOC;IAMnBC,OAAOC,gBAAgBF;AAE3B","ignoreList":[]}