@libmedia/avutil 0.2.0

package/dist/cjs/function/getVideoCodec.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k);
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    desc && !("get" in desc ? !m.__esModule : desc.writable || desc.configurable) || (desc = {
+        enumerable: !0,
+        get: function() {
+            return m[k];
+        }
+    }), Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k), o[k2] = m[k];
+}), __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", {
+        enumerable: !0,
+        value: v
+    });
+} : function(o, v) {
+    o.default = v;
+}), __importStar = this && this.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (null != mod) for (var k in mod) "default" !== k && Object.prototype.hasOwnProperty.call(mod, k) && __createBinding(result, mod, k);
+    return __setModuleDefault(result, mod), result;
+};
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.default = function(codecpar, extradata) {
+    const codecId = cheap__identifier__0.CTypeEnumRead[15](codecpar + 4);
+    let profile = cheap__identifier__0.CTypeEnumRead[15](codecpar + 48), level = cheap__identifier__0.CTypeEnumRead[15](codecpar + 52);
+    !extradata && 0 !== cheap__identifier__0.CTypeEnumRead[20](codecpar + 12) && cheap__identifier__0.CTypeEnumRead[15](codecpar + 16) && (extradata = (0, 
+    memory_1.mapUint8Array)(cheap__identifier__0.CTypeEnumRead[20](codecpar + 12), cheap__identifier__0.CTypeEnumRead[15](codecpar + 16)));
+    let entry = stringEnum_1.CodecId2MimeType[codecId], codec = "";
+    if (27 === codecId) 110 === profile && (profile = 100), codec = string.format("%s.%02x00%02x", entry, 255 & profile, 255 & level); else if (173 === codecId) {
+        let generalProfileSpace = 0, generalProfileCompatibilityFlags = 0, generalTierFlag = 0, constraintFlags = 0;
+        extradata?.length > 13 && (generalProfileSpace = extradata[1] >>> 6 & 3, generalTierFlag = extradata[1] >>> 5 & 1, 
+        generalProfileCompatibilityFlags = extradata[2] | extradata[3] << 8 | extradata[4] << 16 | extradata[5] << 24, 
+        constraintFlags = 240 & extradata[6]);
+        const generalProfileSpaceMap = {
+            0: "",
+            1: "A",
+            2: "B",
+            3: "C"
+        };
+        codec = string.format("%s.%s%d.%x.%s%d.%x", entry, generalProfileSpaceMap[generalProfileSpace], profile, generalProfileCompatibilityFlags, 0 === generalTierFlag ? "L" : "H", level, constraintFlags);
+    } else if (196 === codecId) {
+        let generalTierFlag = 0;
+        if (extradata?.length > 13 && (generalTierFlag = 1 & extradata[5]), codec = string.format("%s.%d.%s%d", entry, profile, 0 === generalTierFlag ? "L" : "H", level), 
+        extradata) {
+            const params = vvc.parseExtraData(extradata);
+            if (params.generalConstraintInfo.length) {
+                let index = params.generalConstraintInfo.length - 1;
+                for (;index > 0 && 0 === params.generalConstraintInfo[index]; ) index--;
+                const generalConstraintInfo = params.generalConstraintInfo.slice(0, index + 1);
+                generalConstraintInfo.length && (codec += `.C${base32.encode(new Uint8Array(generalConstraintInfo), !1)}`);
+            }
+            params.generalSubProfileIdc.length && (codec += `.S${params.generalSubProfileIdc.map((profile => profile.toString(16))).join("+")}`), 
+            codec += `.O${params.olsIdx}+${params.numSublayers}`;
+        }
+    } else if (225 === codecId) if (extradata) {
+        const params = av1.parseExtraData(extradata);
+        codec = string.format("%s.%d.%02d%s.%02d.%d.%d%d%d", entry, params.profile, params.level, params.tier ? "H" : "M", params.bitDepth, params.monochrome, params.chromaSubsamplingX, params.chromaSubsamplingY, params.chromaSamplePosition);
+    } else codec = string.format("%s.%d.%02dM.08", entry, profile, level); else if (139 === codecId) if (extradata) {
+        const params = vp8.parseExtraData(extradata);
+        codec = string.format("%s.%02d.%02d.%02d", entry, params.profile, params.level, params.bitDepth);
+    } else codec = profile !== constant_1.NOPTS_VALUE && level !== constant_1.NOPTS_VALUE ? string.format("%s.%02d.%02d.08", entry, profile, level) : entry; else if (167 === codecId) if (extradata) {
+        const params = vp9.parseExtraData(extradata);
+        codec = string.format("%s.%02d.%02d.%02d.%02d.%02d.%02d.%02d.%02d", entry, params.profile, params.level, params.bitDepth, params.chromaSubsampling, params.colorPrimaries, params.colorTrc, params.colorSpace, params.fullRangeFlag);
+    } else codec = profile !== constant_1.NOPTS_VALUE && level !== constant_1.NOPTS_VALUE ? string.format("%s.%02d.%02d.08.00", entry, profile, level) : string.format("%s.%02d.%02d.08.00", entry, 0, 40); else codec = entry || "unknown";
+    return codec;
+};
+
+const cheap__identifier__0 = require("@libmedia/cheap/ctypeEnumRead"), stringEnum_1 = require("../stringEnum"), av1 = __importStar(require("../codecs/av1")), vp8 = __importStar(require("../codecs/vp8")), vp9 = __importStar(require("../codecs/vp9")), vvc = __importStar(require("../codecs/vvc")), string = __importStar(require("@libmedia/common/util/string")), constant_1 = require("../constant"), memory_1 = require("@libmedia/cheap/std/memory"), base32 = __importStar(require("@libmedia/common/util/base32"));
+//# sourceMappingURL=getVideoCodec.js.map

package/dist/cjs/function/getVideoCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exports","default","codecpar","extradata","codecId","cheap__identifier__0","CTypeEnumRead","profile","level","memory_1","mapUint8Array","entry","stringEnum_1","CodecId2MimeType","codec","string","format","generalProfileSpace","generalProfileCompatibilityFlags","generalTierFlag","constraintFlags","length","generalProfileSpaceMap","params","vvc","parseExtraData","generalConstraintInfo","index","slice","base32","encode","Uint8Array","generalSubProfileIdc","map","toString","join","olsIdx","numSublayers","av1","tier","bitDepth","monochrome","chromaSubsamplingX","chromaSubsamplingY","chromaSamplePosition","vp8","constant_1","NOPTS_VALUE","vp9","chromaSubsampling","colorPrimaries","colorTrc","colorSpace","fullRangeFlag","require","__importStar"],"sources":["../../../function/getVideoCodec.ts"],"mappings":"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","ignoreList":[]}

package/dist/cjs/function/hasAlphaChannel.d.ts

@@ -0,0 +1,2 @@
+import AVCodecParameters from "../struct/avcodecparameters";
+export default function hasAlphaChannel(parameters: pointer<AVCodecParameters>): number | false;

package/dist/cjs/function/hasAlphaChannel.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.default = function(parameters) {
+    if (0 !== cheap__identifier__0.CTypeEnumRead[15](parameters)) return !1;
+    const descriptor = pixelFormatDescriptor_1.PixelFormatDescriptorsMap[cheap__identifier__0.CTypeEnumRead[15](parameters + 28)];
+    return descriptor && 128 & descriptor.flags;
+};
+
+const cheap__identifier__0 = require("@libmedia/cheap/ctypeEnumRead"), pixelFormatDescriptor_1 = require("../pixelFormatDescriptor");
+//# sourceMappingURL=hasAlphaChannel.js.map

package/dist/cjs/function/hasAlphaChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exports","default","parameters","cheap__identifier__0","CTypeEnumRead","descriptor","pixelFormatDescriptor_1","PixelFormatDescriptorsMap","flags","require"],"sources":["../../../function/hasAlphaChannel.ts"],"mappings":";;;;IA6BAA,QAAAC,UAAA,SAAwCC;IACtC,IAAc,MAAVC,qBAAAC,cAAA,IAAAF,aACF,QAAO;IAET,MAAMG,aAAaC,wBAAAC,0BAAyBJ,qBAAAC,cAAA,IAACF,aAAU;IACvD,OAAOG,cAA+B,MAAhBA,WAAWG;AACnC;;uEAVAF,0BAAAG,QAAA","ignoreList":[]}

package/dist/cjs/function/isHdr.d.ts

@@ -0,0 +1,2 @@
+import AVCodecParameters from "../struct/avcodecparameters";
+export default function isHdr(parameters: pointer<AVCodecParameters>): boolean;

package/dist/cjs/function/isHdr.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.default = function(parameters) {
+    if (0 !== cheap__identifier__0.CTypeEnumRead[15](parameters)) return !1;
+    const descriptor = pixelFormatDescriptor_1.PixelFormatDescriptorsMap[cheap__identifier__0.CTypeEnumRead[15](parameters + 28)];
+    if (!descriptor || descriptor.comp[0].depth <= 8) return !1;
+    return 18 === cheap__identifier__0.CTypeEnumRead[15](parameters + 92) || 16 === cheap__identifier__0.CTypeEnumRead[15](parameters + 92);
+};
+
+const cheap__identifier__0 = require("@libmedia/cheap/ctypeEnumRead"), pixelFormatDescriptor_1 = require("../pixelFormatDescriptor");
+//# sourceMappingURL=isHdr.js.map

package/dist/cjs/function/isHdr.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exports","default","parameters","cheap__identifier__0","CTypeEnumRead","descriptor","pixelFormatDescriptor_1","PixelFormatDescriptorsMap","comp","depth","require"],"sources":["../../../function/isHdr.ts"],"mappings":";;;;IA8BAA,QAAAC,UAAA,SAA8BC;IAC5B,IAAc,MAAVC,qBAAAC,cAAA,IAAAF,aACF,QAAO;IAGT,MAAMG,aAAaC,wBAAAC,0BAAyBJ,qBAAAC,cAAA,IAACF,aAAU;IACvD,KAAKG,cAAcA,WAAWG,KAAK,GAAGC,SAAS,GAC7C,QAAO;IAGT,OAAiB,OAAVN,qBAAAC,cAAA,IAAAF,aAAU,OACF,OAAVC,qBAAAC,cAAA,IAAAF,aAAU;AACjB;;uEAjBAI,0BAAAI,QAAA","ignoreList":[]}

package/dist/cjs/function/videoFrame2AVFrame.d.ts

@@ -0,0 +1,7 @@
+import AVFrame from "../struct/avframe";
+import { AVColorPrimaries, AVColorSpace, AVColorTransferCharacteristic, AVPixelFormat } from "../pixfmt";
+export declare function mapFormat(format: VideoPixelFormat): AVPixelFormat.AV_PIX_FMT_NONE | AVPixelFormat.AV_PIX_FMT_YUV420P | AVPixelFormat.AV_PIX_FMT_YUV422P | AVPixelFormat.AV_PIX_FMT_YUV444P | AVPixelFormat.AV_PIX_FMT_NV12 | AVPixelFormat.AV_PIX_FMT_RGBA | AVPixelFormat.AV_PIX_FMT_BGRA | AVPixelFormat.AV_PIX_FMT_YUVA420P | AVPixelFormat.AV_PIX_FMT_RGB0 | AVPixelFormat.AV_PIX_FMT_BGR0;
+export declare function mapColorSpace(colorSpace: string): AVColorSpace.AVCOL_SPC_RGB | AVColorSpace.AVCOL_SPC_BT709 | AVColorSpace.AVCOL_SPC_BT470BG | AVColorSpace.AVCOL_SPC_SMPTE170M;
+export declare function mapColorPrimaries(colorPrimaries: string): AVColorPrimaries.AVCOL_PRI_BT709 | AVColorPrimaries.AVCOL_PRI_BT470BG | AVColorPrimaries.AVCOL_PRI_SMPTE170M;
+export declare function mapColorTrc(colorTrc: string): AVColorTransferCharacteristic.AVCOL_TRC_BT709 | AVColorTransferCharacteristic.AVCOL_TRC_SMPTE170M | AVColorTransferCharacteristic.AVCOL_TRC_IEC61966_2_1;
+export declare function videoFrame2AVFrame(videoFrame: VideoFrame, avframe?: pointer<AVFrame>): pointer<AVFrame>;

package/dist/cjs/function/videoFrame2AVFrame.js

@@ -0,0 +1,111 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), exports.mapFormat = mapFormat, exports.mapColorSpace = mapColorSpace, exports.mapColorPrimaries = mapColorPrimaries, 
+exports.mapColorTrc = mapColorTrc, exports.videoFrame2AVFrame = function(videoFrame, avframe = 0) {
+    0 === avframe && (avframe = (0, avframe_1.createAVFrame)());
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 80, mapFormat(videoFrame.format)), 
+    cheap__identifier__1.CTypeEnumWrite[17](avframe + 104, BigInt(Math.floor(videoFrame.timestamp))), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 68, videoFrame.codedWidth), cheap__identifier__1.CTypeEnumWrite[15](avframe + 72, videoFrame.codedHeight), 
+    cheap__identifier__1.CTypeEnumWrite[17](avframe + 312, BigInt(Math.floor(videoFrame.duration))), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 220, mapColorSpace(videoFrame.colorSpace.matrix)), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 212, mapColorPrimaries(videoFrame.colorSpace.primaries)), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 216, mapColorTrc(videoFrame.colorSpace.transfer)), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 208, videoFrame.colorSpace.fullRange ? 2 : 1), 
+    videoFrame.visibleRect && (cheap__identifier__1.CTypeEnumWrite[15](avframe + 276, videoFrame.visibleRect.left), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 280, videoFrame.visibleRect.right), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 268, videoFrame.visibleRect.top), 
+    cheap__identifier__1.CTypeEnumWrite[15](avframe + 272, videoFrame.visibleRect.bottom));
+    (0, avframe_1.getVideoBuffer)(avframe);
+    const des = pixelFormatDescriptor_1.PixelFormatDescriptorsMap[cheap__identifier__0.CTypeEnumRead[15](avframe + 80)], layout = [];
+    for (let i = 0; i < des.nbComponents; i++) des.comp[i].plane >= i && layout.push({
+        offset: cheap__identifier__0.CTypeEnumRead[20](avframe + 4 * i),
+        stride: cheap__identifier__0.CTypeEnumRead[15](avframe + 32 + 4 * i)
+    });
+    return videoFrame.copyTo((0, heap_1.getHeapU8)(), {
+        layout: layout
+    }), avframe;
+};
+
+const cheap__identifier__0 = require("@libmedia/cheap/ctypeEnumRead"), cheap__identifier__1 = require("@libmedia/cheap/ctypeEnumWrite"), avframe_1 = require("../util/avframe"), pixelFormatDescriptor_1 = require("../pixelFormatDescriptor"), heap_1 = require("@libmedia/cheap/heap");
+
+function mapFormat(format) {
+    switch (format) {
+      case "BGRA":
+        return 28;
+
+      case "BGRX":
+        return 121;
+
+      case "I420":
+        return 0;
+
+      case "I420A":
+        return 33;
+
+      case "I422":
+        return 4;
+
+      case "I444":
+        return 5;
+
+      case "NV12":
+        return 23;
+
+      case "RGBA":
+        return 26;
+
+      case "RGBX":
+        return 119;
+
+      default:
+        return -1;
+    }
+}
+
+function mapColorSpace(colorSpace) {
+    switch (colorSpace) {
+      case "bt709":
+      default:
+        return 1;
+
+      case "smpte170m":
+        return 6;
+
+      case "bt470bg":
+        return 5;
+
+      case "rgb":
+        return 0;
+    }
+}
+
+function mapColorPrimaries(colorPrimaries) {
+    switch (colorPrimaries) {
+      case "bt709":
+      default:
+        return 1;
+
+      case "bt470bg":
+        return 5;
+
+      case "smpte170m":
+        return 6;
+    }
+}
+
+function mapColorTrc(colorTrc) {
+    switch (colorTrc) {
+      case "bt709":
+      default:
+        return 1;
+
+      case "iec61966-2-1":
+        return 13;
+
+      case "smpte170m":
+        return 6;
+    }
+}
+//# sourceMappingURL=videoFrame2AVFrame.js.map

package/dist/cjs/function/videoFrame2AVFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exports","mapFormat","mapColorSpace","mapColorPrimaries","mapColorTrc","videoFrame2AVFrame","videoFrame","avframe","avframe_1","createAVFrame","cheap__identifier__1","CTypeEnumWrite","format","BigInt","Math","floor","timestamp","codedWidth","codedHeight","duration","colorSpace","matrix","primaries","transfer","fullRange","visibleRect","left","right","top","bottom","getVideoBuffer","des","pixelFormatDescriptor_1","PixelFormatDescriptorsMap","cheap__identifier__0","CTypeEnumRead","layout","i","nbComponents","comp","plane","push","offset","stride","copyTo","heap_1","getHeapU8","require","colorPrimaries","colorTrc"],"sources":["../../../function/videoFrame2AVFrame.ts"],"mappings":";;;;IA8BAA,QAAAC,uBAyBAD,QAAAE,+BAeAF,QAAAG;AAaAH,QAAAI,2BAaAJ,QAAAK,qBAAA,SAAmCC,YAAwBC,UAAA;IAC9C,MAAPA,YACFA,WAAU,GAAAC,UAAAC;IAGZC,qBAAAC,eAAA,IAAAJ,UAAO,IAAUN,UAAUK,WAAWM;IACtCF,qBAAAC,eAAA,IAAAJ,UAAO,KAAAM,OAAAC,KAAAC,MAA0BT,WAAWU;IAC5CN,qBAAAC,eAAA,IAAAJ,UAAO,IAASD,WAAWW,aAC3BP,qBAAAC,eAAA,IAAAJ,UAAO,IAAUD,WAAWY;IAC5BR,qBAAAC,eAAA,IAAAJ,UAAO,KAAAM,OAAAC,KAAAC,MAA+BT,WAAWa;IAEjDT,qBAAAC,eAAA,IAAAJ,UAAO,KAAcL,cAAcI,WAAWc,WAAWC;IACzDX,qBAAAC,eAAA,IAAAJ,UAAO,KAAkBJ,kBAAkBG,WAAWc,WAAWE;IACjEZ,qBAAAC,eAAA,IAAAJ,UAAO,KAAYH,YAAYE,WAAWc,WAAWG;IACrDb,qBAAAC,eAAA,IAAAJ,UAAO,KAAcD,WAAWc,WAAWI,YAAW,IAAgC;IAElFlB,WAAWmB,gBACbf,qBAAAC,eAAA,IAAAJ,UAAO,KAAYD,WAAWmB,YAAYC;IAC1ChB,qBAAAC,eAAA,IAAAJ,UAAO,KAAaD,WAAWmB,YAAYE;IAC3CjB,qBAAAC,eAAA,IAAAJ,UAAO,KAAWD,WAAWmB,YAAYG;IACzClB,qBAAAC,eAAA,IAAAJ,UAAO,KAAcD,WAAWmB,YAAYI;KAG9C,GAAArB,UAAAsB,gBAAevB;IAEf,MAAMwB,MAAMC,wBAAAC,0BAA0BC,qBAAAC,cAAA,IAAA5B,UAAO,MACvC6B,SAAwB;IAC9B,KAAK,IAAIC,IAAI,GAAGA,IAAIN,IAAIO,cAAcD,KAChCN,IAAIQ,KAAKF,GAAGG,SAASH,KACvBD,OAAOK,KAAK;QACVC,QAAMR,qBAAAC,cAAA,IAAE5B,UAAO;QACfoC,QAAMT,qBAAAC,cAAA,IAAE5B,UAAO;;IASrB,OAJAD,WAAWsC,QAAO,GAAAC,OAAAC,cAAa;QAC7BV;QAGK7B;AACT;;yIAjHAC,YAAAuC,QAAA,oBAGAf,0BAAAe,QAAA,6BACAF,SAAAE,QAAA;;AAEA,SAAgB9C,UAAUW;IACxB,QAAQA;MACN,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;MACF;QACE;;AAEN;;AAEA,SAAgBV,cAAckB;IAC5B,QAAQA;MACN,KAAK;MAQL;QACE;;MAPF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;AAIN;;AAEA,SAAgBjB,kBAAkB6C;IAChC,QAAQA;MACN,KAAK;MAML;QACE;;MALF,KAAK;QACH;;MACF,KAAK;QACH;;AAIN;;AAEA,SAAgB5C,YAAY6C;IAC1B,QAAQA;MACN,KAAK;MAML;QACE;;MALF,KAAK;QACH;;MACF,KAAK;QACH;;AAIN","ignoreList":[]}

package/dist/cjs/implement/AVFramePoolImpl.d.ts

@@ -0,0 +1,10 @@
+import { AVFramePool, AVFrameRef } from "../struct/avframe";
+import List from "@libmedia/cheap/std/collection/List";
+import { Mutex } from "@libmedia/cheap/thread/mutex";
+export default class AVFramePoolImpl implements AVFramePool {
+    private list;
+    private mutex;
+    constructor(list: List<pointer<AVFrameRef>>, mutex?: pointer<Mutex>);
+    alloc(): pointer<AVFrameRef>;
+    release(avframe: pointer<AVFrameRef>): void;
+}

package/dist/cjs/implement/AVFramePoolImpl.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k);
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    desc && !("get" in desc ? !m.__esModule : desc.writable || desc.configurable) || (desc = {
+        enumerable: !0,
+        get: function() {
+            return m[k];
+        }
+    }), Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k), o[k2] = m[k];
+}), __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", {
+        enumerable: !0,
+        value: v
+    });
+} : function(o, v) {
+    o.default = v;
+}), __importStar = this && this.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (null != mod) for (var k in mod) "default" !== k && Object.prototype.hasOwnProperty.call(mod, k) && __createBinding(result, mod, k);
+    return __setModuleDefault(result, mod), result;
+};
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+
+require("@libmedia/cheap/ctypeEnumRead");
+
+const cheap__identifier__2 = require("@libmedia/cheap/ctypeEnumWrite"), atomics = (require("../struct/avframe"), 
+__importStar(require("@libmedia/cheap/thread/atomics"))), mutex = __importStar(require("@libmedia/cheap/thread/mutex")), mem_1 = require("../util/mem"), avframe_2 = require("../util/avframe");
+
+exports.default = class {
+    list;
+    mutex;
+    constructor(list, mutex) {
+        this.list = list, this.mutex = mutex;
+    }
+    alloc() {
+        let avframe = this.list.find((avframe => -1 === atomics.compareExchange(avframe + 320, -1, 1, 16, 2)), 20);
+        return avframe || (avframe = (0, mem_1.avMallocz)(328), (0, avframe_2.getAVFrameDefault)(avframe), 
+        cheap__identifier__2.CTypeEnumWrite[16](avframe + 320, 1), mutex.lock(this.mutex), 
+        this.list.push(avframe, 20), mutex.unlock(this.mutex)), avframe;
+    }
+    release(avframe) {
+        atomics.load(avframe + 320, 16, 2) <= 0 || 1 === atomics.sub(avframe + 320, 1, 16, 2) && ((0, 
+        avframe_2.unrefAVFrame)(avframe), atomics.store(avframe + 320, -1, 16, 2));
+    }
+};
+//# sourceMappingURL=AVFramePoolImpl.js.map

package/dist/cjs/implement/AVFramePoolImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["atomics","require","__importStar","mutex","mem_1","avframe_2","exports","default","list","constructor","this","alloc","avframe","find","compareExchange","avMallocz","getAVFrameDefault","cheap__identifier__2","CTypeEnumWrite","lock","push","unlock","release","load","sub","unrefAVFrame","store"],"sources":["../../../implement/AVFramePoolImpl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEA4BAA,WAHAC,QAAA;AAGAC,aAAAD,QAAA,qCACAE,QAAAD,aAAAD,QAAA,kCACAG,QAAAH,QAAA,gBACAI,YAAAJ,QAAA;;AAEAK,QAAAC,UAAA;IAEUC;IAEAL;IAER,WAAAM,CAAYD,MAAiCL;QAC3CO,KAAKF,OAAOA,MACZE,KAAKP,QAAQA;AACf;IAEO,KAAAQ;QACL,IAAIC,UAAUF,KAAKF,KAAKK,MAAMD,YAC4C,MAAjEZ,QAAQc,gBAA0BF,UAAO,MAAa,GAAG,GAAC,SAClE;QAoBD,OAnBKA,YACHA,WAAU,GAAAR,MAAAW,WAAS,OAEnB,GAAAV,UAAAW,mBAAkBJ;QAElBK,qBAAAC,eAAA,IAAAN,UAAO,KAAY,IAIjBT,MAAMgB,KAAKT,KAAKP;QAGlBO,KAAKF,KAAKY,KAAKR,SAAO,KAGpBT,MAAMkB,OAAOX,KAAKP,SAIfS;AACT;IACO,OAAAU,CAAQV;QACTZ,QAAQuB,KAAeX,UAAO,eAAe,KAGG,MAAhDZ,QAAQwB,IAAcZ,UAAO,KAAY,GAAC,YAC5C;QAAAP,UAAAoB,cAAab,UACbZ,QAAQ0B,MAAgBd,UAAO,MAAa,GAAC;AAEjD","ignoreList":[]}

package/dist/cjs/implement/AVPCMBufferPoolImpl.d.ts

@@ -0,0 +1,10 @@
+import { AVPCMBufferPool, AVPCMBufferRef } from "../struct/avpcmbuffer";
+import List from "@libmedia/cheap/std/collection/List";
+import { Mutex } from "@libmedia/cheap/thread/mutex";
+export default class AVPCMBufferPoolImpl implements AVPCMBufferPool {
+    private list;
+    private mutex;
+    constructor(list: List<pointer<AVPCMBufferRef>>, mutex?: pointer<Mutex>);
+    alloc(): pointer<AVPCMBufferRef>;
+    release(buffer: pointer<AVPCMBufferRef>): void;
+}

package/dist/cjs/implement/AVPCMBufferPoolImpl.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k);
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    desc && !("get" in desc ? !m.__esModule : desc.writable || desc.configurable) || (desc = {
+        enumerable: !0,
+        get: function() {
+            return m[k];
+        }
+    }), Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k), o[k2] = m[k];
+}), __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", {
+        enumerable: !0,
+        value: v
+    });
+} : function(o, v) {
+    o.default = v;
+}), __importStar = this && this.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (null != mod) for (var k in mod) "default" !== k && Object.prototype.hasOwnProperty.call(mod, k) && __createBinding(result, mod, k);
+    return __setModuleDefault(result, mod), result;
+};
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+
+require("@libmedia/cheap/ctypeEnumRead");
+
+const cheap__identifier__2 = require("@libmedia/cheap/ctypeEnumWrite"), atomics = (require("../struct/avpcmbuffer"), 
+__importStar(require("@libmedia/cheap/thread/atomics"))), mutex = __importStar(require("@libmedia/cheap/thread/mutex")), mem_1 = require("../util/mem");
+
+exports.default = class {
+    list;
+    mutex;
+    constructor(list, mutex) {
+        this.list = list, this.mutex = mutex;
+    }
+    alloc() {
+        let buffer = this.list.find((buffer => -1 === atomics.compareExchange(buffer + 40, -1, 1, 16, 2)), 20);
+        return buffer || (buffer = (0, mem_1.avMallocz)(48), cheap__identifier__2.CTypeEnumWrite[16](buffer + 40, 1), 
+        mutex.lock(this.mutex), this.list.push(buffer, 20), mutex.unlock(this.mutex)), buffer;
+    }
+    release(buffer) {
+        atomics.load(buffer + 40, 16, 2) <= 0 || 1 === atomics.sub(buffer + 40, 1, 16, 2) && atomics.store(buffer + 40, -1, 16, 2);
+    }
+};
+//# sourceMappingURL=AVPCMBufferPoolImpl.js.map

package/dist/cjs/implement/AVPCMBufferPoolImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["atomics","require","__importStar","mutex","mem_1","exports","default","list","constructor","this","alloc","buffer","find","compareExchange","avMallocz","cheap__identifier__2","CTypeEnumWrite","lock","push","unlock","release","load","sub","store"],"sources":["../../../implement/AVPCMBufferPoolImpl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEA4BAA,WAHAC,QAAA;AAGAC,aAAAD,QAAA,qCACAE,QAAAD,aAAAD,QAAA,kCACAG,QAAAH,QAAA;;AAEAI,QAAAC,UAAA;IAEUC;IAEAJ;IAER,WAAAK,CAAYD,MAAqCJ;QAC/CM,KAAKF,OAAOA,MACZE,KAAKN,QAAQA;AACf;IAEO,KAAAO;QACL,IAAIC,SAASF,KAAKF,KAAKK,MAAMD,WAC4C,MAAhEX,QAAQa,gBAA0BF,SAAM,KAAa,GAAG,GAAC,SACjE;QAkBD,OAjBKA,WACHA,UAAS,GAAAP,MAAAU,WAAS,KAElBC,qBAAAC,eAAA,IAAAL,SAAM,IAAY;QAIhBR,MAAMc,KAAKR,KAAKN,QAGlBM,KAAKF,KAAKW,KAAKP,QAAM,KAGnBR,MAAMgB,OAAOV,KAAKN,SAIfQ;AACT;IACO,OAAAS,CAAQT;QACTX,QAAQqB,KAAeV,SAAM,cAAe,KAGG,MAA/CX,QAAQsB,IAAcX,SAAM,IAAY,GAAC,UAC3CX,QAAQuB,MAAgBZ,SAAM,KAAa,GAAC;AAEhD","ignoreList":[]}

package/dist/cjs/implement/AVPacketPoolImpl.d.ts

@@ -0,0 +1,10 @@
+import List from "@libmedia/cheap/std/collection/List";
+import { Mutex } from "@libmedia/cheap/thread/mutex";
+import { AVPacketPool, AVPacketRef } from "../struct/avpacket";
+export default class AVPacketPoolImpl implements AVPacketPool {
+    private list;
+    private mutex;
+    constructor(list: List<pointer<AVPacketRef>>, mutex?: pointer<Mutex>);
+    alloc(): pointer<AVPacketRef>;
+    release(avpacket: pointer<AVPacketRef>): void;
+}

package/dist/cjs/implement/AVPacketPoolImpl.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k);
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    desc && !("get" in desc ? !m.__esModule : desc.writable || desc.configurable) || (desc = {
+        enumerable: !0,
+        get: function() {
+            return m[k];
+        }
+    }), Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k), o[k2] = m[k];
+}), __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", {
+        enumerable: !0,
+        value: v
+    });
+} : function(o, v) {
+    o.default = v;
+}), __importStar = this && this.__importStar || function(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (null != mod) for (var k in mod) "default" !== k && Object.prototype.hasOwnProperty.call(mod, k) && __createBinding(result, mod, k);
+    return __setModuleDefault(result, mod), result;
+};
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+
+require("@libmedia/cheap/ctypeEnumRead");
+
+const cheap__identifier__2 = require("@libmedia/cheap/ctypeEnumWrite"), atomics = __importStar(require("@libmedia/cheap/thread/atomics")), mutex = __importStar(require("@libmedia/cheap/thread/mutex")), mem_1 = require("../util/mem"), avpacket_2 = (require("../struct/avpacket"), 
+require("../util/avpacket"));
+
+exports.default = class {
+    list;
+    mutex;
+    constructor(list, mutex) {
+        this.list = list, this.mutex = mutex;
+    }
+    alloc() {
+        let avpacket = this.list.find((avpacket => -1 === atomics.compareExchange(avpacket + 88, -1, 1, 16, 2)), 20);
+        return avpacket || (avpacket = (0, mem_1.avMallocz)(96), (0, avpacket_2.getAVPacketDefault)(avpacket), 
+        cheap__identifier__2.CTypeEnumWrite[16](avpacket + 88, 1), mutex.lock(this.mutex), 
+        this.list.push(avpacket, 20), mutex.unlock(this.mutex)), avpacket;
+    }
+    release(avpacket) {
+        atomics.load(avpacket + 88, 16, 2) <= 0 || 1 === atomics.sub(avpacket + 88, 1, 16, 2) && ((0, 
+        avpacket_2.unrefAVPacket)(avpacket), atomics.store(avpacket + 88, -1, 16, 2));
+    }
+};
+//# sourceMappingURL=AVPacketPoolImpl.js.map

package/dist/cjs/implement/AVPacketPoolImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["atomics","__importStar","require","mutex","mem_1","avpacket_2","exports","default","list","constructor","this","alloc","avpacket","find","compareExchange","avMallocz","getAVPacketDefault","cheap__identifier__2","CTypeEnumWrite","lock","push","unlock","release","load","sub","unrefAVPacket","store"],"sources":["../../../implement/AVPacketPoolImpl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wEA2BAA,UAAAC,aAAAC,QAAA,oCACAC,QAAAF,aAAAC,QAAA,kCACAE,QAAAF,QAAA,gBAEAG,cADAH,QAAA;AACAA,QAAA;;AAEAI,QAAAC,UAAA;IAEUC;IAEAL;IAER,WAAAM,CAAYD,MAAkCL;QAC5CO,KAAKF,OAAOA,MACZE,KAAKP,QAAQA;AACf;IAEO,KAAAQ;QACL,IAAIC,WAAWF,KAAKF,KAAKK,MAAMD,aAC4C,MAAlEZ,QAAQc,gBAA0BF,WAAQ,KAAa,GAAG,GAAC,SACnE;QAmBD,OAlBKA,aACHA,YAAW,GAAAR,MAAAW,WAAS,MACpB,GAAAV,WAAAW,oBAAmBJ;QAEnBK,qBAAAC,eAAA,IAAAN,WAAQ,IAAY,IAIlBT,MAAMgB,KAAKT,KAAKP;QAGlBO,KAAKF,KAAKY,KAAKR,UAAQ,KAGrBT,MAAMkB,OAAOX,KAAKP,SAIfS;AACT;IACO,OAAAU,CAAQV;QACTZ,QAAQuB,KAAeX,WAAQ,cAAe,KAGG,MAAjDZ,QAAQwB,IAAcZ,WAAQ,IAAY,GAAC,YAC7C;QAAAP,WAAAoB,eAAcb,WACdZ,QAAQ0B,MAAgBd,WAAQ,KAAa,GAAC;AAElD","ignoreList":[]}

package/dist/cjs/pixelFormatDescriptor.d.ts

@@ -0,0 +1,100 @@
+import { AVPixelFormat } from "./pixfmt";
+export declare const enum PixelFormatFlags {
+    /**
+     * Pixel format is big-endian.
+     */
+    BIG_ENDIAN = 1,
+    /**
+     * Pixel format has a palette in data[1], values are indexes in this palette.
+     */
+    PALETTE = 2,
+    /**
+     * All values of a component are bit-wise packed end to end.
+     */
+    BIT_STREAM = 4,
+    /**
+     * At least one pixel component is not in the first data plane.
+     */
+    PLANER = 16,
+    /**
+     * The pixel format contains RGB-like data (as opposed to YUV/grayscale).
+     */
+    RGB = 32,
+    /**
+     * The pixel format has an alpha channel. This is set on all formats that
+     * support alpha in some way, including AV_PIX_FMT_PAL8. The alpha is always
+     * straight, never pre-multiplied.
+     *
+     * If a codec or a filter does not support alpha, it should set all alpha to
+     * opaque, or use the equivalent pixel formats without alpha component, e.g.
+     * AV_PIX_FMT_RGB0 (or AV_PIX_FMT_RGB24 etc.) instead of AV_PIX_FMT_RGBA.
+     */
+    ALPHA = 128,
+    /**
+     * The pixel format is following a Bayer pattern
+     */
+    BAYER = 256,
+    /**
+     * The pixel format contains IEEE-754 floating point values. Precision (double,
+     * single, or half) should be determined by the pixel size (64, 32, or 16 bits).
+     */
+    FLOAT = 512
+}
+export type PixelFormatDescriptor = {
+    nbComponents: number;
+    /**
+     * Amount to shift the luma width right to find the chroma width.
+     * For YV12 this is 1 for example.
+     * chroma_width = AV_CEIL_RSHIFT(luma_width, log2_chroma_w)
+     * The note above is needed to ensure rounding up.
+     * This value only refers to the chroma components.
+     */
+    log2ChromaW: number;
+    /**
+     * Amount to shift the luma height right to find the chroma height.
+     * For YV12 this is 1 for example.
+     * chroma_height= AV_CEIL_RSHIFT(luma_height, log2_chroma_h)
+     * The note above is needed to ensure rounding up.
+     * This value only refers to the chroma components.
+     */
+    log2ChromaH: number;
+    /**
+     * Combination of AV_PIX_FMT_FLAG_... flags.
+     */
+    flags: number;
+    /**
+     * Parameters that describe how pixels are packed.
+     * If the format has 1 or 2 components, then luma is 0.
+     * If the format has 3 or 4 components:
+     *   if the RGB flag is set then 0 is red, 1 is green and 2 is blue;
+     *   otherwise 0 is luma, 1 is chroma-U and 2 is chroma-V.
+     *
+     * If present, the Alpha channel is always the last component.
+     */
+    comp: {
+        /**
+         * Which of the 4 planes contains the component.
+         */
+        plane: number;
+        /**
+         * Number of elements between 2 horizontally consecutive pixels.
+         * Elements are bits for bitstream formats, bytes otherwise.
+         */
+        step: number;
+        /**
+         * Number of elements before the component of the first pixel.
+         * Elements are bits for bitstream formats, bytes otherwise.
+         */
+        offset: number;
+        /**
+         * Number of least significant bits that must be shifted away
+         * to get the value.
+         */
+        shift: number;
+        /**
+         * Number of bits in the component.
+         */
+        depth: number;
+    }[];
+};
+export declare const PixelFormatDescriptorsMap: Partial<Record<AVPixelFormat, PixelFormatDescriptor>>;