@libmedia/avutil 0.2.0

package/dist/esm/function/audioData2AVFrame.js

@@ -0,0 +1,51 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { createAVFrame, getAudioBuffer } from "../util/avframe";
+
+import { sampleFormatIsPlanar } from "../util/sample";
+
+import { mapUint8Array } from "@libmedia/cheap/std/memory";
+
+export function audioData2AVFrame(audioData, avframe = 0) {
+    0 === avframe && (avframe = createAVFrame()), cheap__CTypeEnumWrite__1[15](avframe + 152, audioData.sampleRate), 
+    cheap__CTypeEnumWrite__1[15](avframe + 76, audioData.numberOfFrames), cheap__CTypeEnumWrite__1[15](avframe + 292, audioData.numberOfChannels), 
+    cheap__CTypeEnumWrite__1[15](avframe + 80, function(format) {
+        switch (format) {
+          case "u8":
+            return 0;
+
+          case "s16":
+            return 1;
+
+          case "s32":
+            return 2;
+
+          case "f32":
+            return 3;
+
+          case "u8-planar":
+            return 5;
+
+          case "s16-planar":
+            return 6;
+
+          case "s32-planar":
+            return 7;
+
+          case "f32-planar":
+            return 8;
+
+          default:
+            throw new Error("not support");
+        }
+    }(audioData.format)), cheap__CTypeEnumWrite__1[17](avframe + 104, BigInt(Math.floor(audioData.timestamp))), 
+    getAudioBuffer(avframe);
+    const planes = sampleFormatIsPlanar(cheap__CTypeEnumRead__0[15](avframe + 80)) ? cheap__CTypeEnumRead__0[15](avframe + 292) : 1;
+    for (let i = 0; i < planes; i++) audioData.copyTo(mapUint8Array(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](avframe + 64) + 4 * i), cheap__CTypeEnumRead__0[15](avframe + 32)), {
+        planeIndex: i
+    });
+    return avframe;
+}
+//# sourceMappingURL=audioData2AVFrame.js.map

package/dist/esm/function/audioData2AVFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAVFrame","getAudioBuffer","sampleFormatIsPlanar","mapUint8Array","audioData2AVFrame","audioData","avframe","cheap__CTypeEnumWrite__1","sampleRate","numberOfFrames","numberOfChannels","format","Error","mapFormat","BigInt","Math","floor","timestamp","planes","cheap__CTypeEnumRead__0","i","copyTo","planeIndex"],"sources":["../../../function/audioData2AVFrame.ts"],"mappings":";;;;SAwBSA,eAAeC,sBAAgB;;SAG/BC,4BAAsB;;SACtBC,qBAAe;;OAyBlB,SAAUC,kBAAkBC,WAAsBC,UAAA;IAC3C,MAAPA,YACFA,UAAUN,kBAGZO,yBAAA,IAAAD,UAAO,KAAcD,UAAUG;IAC/BD,yBAAA,IAAAD,UAAO,IAAaD,UAAUI,iBAC9BF,yBAAA,IAAAD,UAAO,KAAuBD,UAAUK;IACxCH,yBAAA,IAAAD,UAAO,IA/BT,SAAmBK;QACjB,QAAQA;UACN,KAAK;YACH;;UACF,KAAK;YACH;;UACF,KAAK;YACH;;UACF,KAAK;YACH;;UACF,KAAK;YACH;;UACF,KAAK;YACH;;UACF,KAAK;YACH;;UACF,KAAK;YACH;;UACF;YACE,MAAM,IAAIC,MAAM;;AAEtB,KAUmBC,CAAUR,UAAUM,UACrCJ,yBAAA,IAAAD,UAAO,KAAAQ,OAAAC,KAAAC,MAA0BX,UAAUY;IAE3ChB,eAAeK;IAEf,MACMY,SADShB,qBAAoBiB,wBAAA,IAACb,UAAO,OACpBa,wBAAA,IAACb,UAAO,OAAuB;IAEtD,KAAK,IAAIc,IAAI,GAAGA,IAAIF,QAAQE,KAC1Bf,UAAUgB,OAAOlB,cAAagB,wBAAA,IAAAA,wBAAA,IAACb,UAAO,MAAe,IAADc,IAACD,wBAAA,IAAGb,UAAO,MAAe;QAC5EgB,YAAYF;;IAIhB,OAAOd;AACT","ignoreList":[]}

package/dist/esm/function/avframe2AudioData.d.ts

@@ -0,0 +1,3 @@
+import AVFrame from "../struct/avframe";
+import { Rational } from "../struct/rational";
+export declare function avframe2AudioData(avframe: pointer<AVFrame>, timeBase?: Rational): AudioData;

package/dist/esm/function/avframe2AudioData.js

@@ -0,0 +1,104 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { mapFloat32Array, mapInt16Array, mapInt32Array, mapUint8Array } from "@libmedia/cheap/std/memory";
+
+import { getBytesPerSample, sampleFormatIsPlanar } from "../util/sample";
+
+import { avRescaleQ } from "../util/rational";
+
+import { AV_TIME_BASE_Q } from "../constant";
+
+function mapFormat(avframe) {
+    switch (cheap__CTypeEnumRead__0[15](avframe + 80)) {
+      case 0:
+        return "u8";
+
+      case 1:
+        return "s16";
+
+      case 2:
+        return "s32";
+
+      case 3:
+        return "f32";
+
+      case 5:
+        return "u8-planar";
+
+      case 6:
+        return "s16-planar";
+
+      case 7:
+        return "s32-planar";
+
+      case 8:
+        return "f32-planar";
+
+      default:
+        throw new Error("not support");
+    }
+}
+
+export function avframe2AudioData(avframe, timeBase) {
+    const planar = sampleFormatIsPlanar(cheap__CTypeEnumRead__0[15](avframe + 80)), planes = planar ? cheap__CTypeEnumRead__0[15](avframe + 292) : 1;
+    let data;
+    const sampleSize = getBytesPerSample(cheap__CTypeEnumRead__0[15](avframe + 80));
+    if (planar) {
+        const linesize = cheap__CTypeEnumRead__0[15](avframe + 76) * sampleSize, buffer = new Uint8Array(planes * linesize);
+        let offset = 0;
+        for (let i = 0; i < planes; i++) buffer.set(mapUint8Array(cheap__CTypeEnumRead__0[20](avframe + 4 * i), linesize), offset), 
+        offset += linesize;
+        data = function(format, data) {
+            switch (format) {
+              case 0:
+              case 5:
+                return data;
+
+              case 1:
+              case 6:
+                return new Int16Array(data.buffer);
+
+              case 2:
+              case 7:
+                return new Int32Array(data.buffer);
+
+              case 3:
+              case 8:
+                return new Float32Array(data.buffer);
+
+              default:
+                throw new Error("not support");
+            }
+        }(cheap__CTypeEnumRead__0[15](avframe + 80), buffer);
+    } else data = function(format, pointer, size) {
+        switch (format) {
+          case 0:
+          case 5:
+            return mapUint8Array(pointer, size);
+
+          case 1:
+          case 6:
+            return mapInt16Array(pointer, size >>> 1);
+
+          case 2:
+          case 7:
+            return mapInt32Array(pointer, size >>> 2);
+
+          case 3:
+          case 8:
+            return mapFloat32Array(pointer, size >>> 2);
+
+          default:
+            throw new Error("not support");
+        }
+    }(cheap__CTypeEnumRead__0[15](avframe + 80), cheap__CTypeEnumRead__0[20](avframe), sampleSize * cheap__CTypeEnumRead__0[15](avframe + 76) * cheap__CTypeEnumRead__0[15](avframe + 292));
+    return new AudioData({
+        data: data,
+        format: mapFormat(avframe),
+        sampleRate: cheap__CTypeEnumRead__0[15](avframe + 152),
+        numberOfFrames: cheap__CTypeEnumRead__0[15](avframe + 76),
+        numberOfChannels: cheap__CTypeEnumRead__0[15](avframe + 292),
+        timestamp: Number(timeBase ? avRescaleQ(cheap__CTypeEnumRead__0[17](avframe + 104), timeBase, AV_TIME_BASE_Q) : cheap__CTypeEnumRead__0[17](avframe + 104))
+    });
+}
+//# sourceMappingURL=avframe2AudioData.js.map

package/dist/esm/function/avframe2AudioData.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["mapFloat32Array","mapInt16Array","mapInt32Array","mapUint8Array","getBytesPerSample","sampleFormatIsPlanar","avRescaleQ","AV_TIME_BASE_Q","mapFormat","avframe","cheap__CTypeEnumRead__0","Error","avframe2AudioData","timeBase","planar","planes","data","sampleSize","linesize","buffer","Uint8Array","offset","i","set","format","Int16Array","Int32Array","Float32Array","mapBuffer","pointer","size","mapTypeBuffer","AudioData","sampleRate","numberOfFrames","numberOfChannels","timestamp","Number"],"sources":["../../../function/avframe2AudioData.ts"],"mappings":";;SAyBSA,iBAAiBC,eAAeC,eAAeC,qBAAe;;SAG9DC,mBAAmBC,4BAAsB;;SAEzCC,kBAAY;;SACZC,sBAAgB;;AAEzB,SAASC,UAAUC;IACjB,QAAAC,wBAAA,IAAQD,UAAO;MACb;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,MAAM,IAAIE,MAAM;;AAEtB;;OAwCM,SAAUC,kBAAkBH,SAA2BI;IAE3D,MAAMC,SAAST,qBAAoBK,wBAAA,IAACD,UAAO,MACrCM,SAASD,SAAQJ,wBAAA,IAACD,UAAO,OAAuB;IAEtD,IAAIO;IAEJ,MAAMC,aAAab,kBAAiBM,wBAAA,IAACD,UAAO;IAE5C,IAAIK,QAAQ;QACV,MAAMI,WAAWR,wBAAA,IAAAD,UAAO,MAAcQ,YAChCE,SAAS,IAAIC,WAAWL,SAASG;QACvC,IAAIG,SAAS;QACb,KAAK,IAAIC,IAAI,GAAGA,IAAIP,QAAQO,KAC1BH,OAAOI,IAAIpB,cAAaO,wBAAA,IAACD,UAAO,QAAUS,WAAWG;QACrDA,UAAUH;QAEZF,OAvDJ,SAAmBQ,QAAwBR;YACzC,QAAQQ;cACN;cACA;gBACE,OAAOR;;cACT;cACA;gBACE,OAAO,IAAIS,WAAWT,KAAKG;;cAC7B;cACA;gBACE,OAAO,IAAIO,WAAWV,KAAKG;;cAC7B;cACA;gBACE,OAAO,IAAIQ,aAAaX,KAAKG;;cAC/B;gBACE,MAAM,IAAIR,MAAM;;AAEtB,SAsCWiB,CAASlB,wBAAA,IAACD,UAAO,KAASU;AACnC,WAEEH,OAvCJ,SAAuBQ,QAAwBK,SAAwBC;QACrE,QAAQN;UACN;UACA;YACE,OAAOrB,cAAc0B,SAASC;;UAChC;UACA;YACE,OAAO7B,cAA+C4B,SAAUC,SAAS;;UAC3E;UACA;YACE,OAAO5B,cAA+C2B,SAAUC,SAAS;;UAC3E;UACA;YACE,OAAO9B,gBAAiD6B,SAAUC,SAAS;;UAC7E;YACE,MAAM,IAAInB,MAAM;;AAEtB,KAsBWoB,CAAarB,wBAAA,IAACD,UAAO,KAAAC,wBAAA,IAASD,UAAiBQ,aAAUP,wBAAA,IAAGD,UAAO,MAAUC,wBAAA,IAAGD,UAAO;IAWhG,OARkB,IAAIuB,UAAU;QAC9BhB;QACAQ,QAAQhB,UAAUC;QAClBwB,YAAUvB,wBAAA,IAAED,UAAO;QACnByB,gBAAcxB,wBAAA,IAAED,UAAO;QACvB0B,kBAAgBzB,wBAAA,IAAED,UAAO;QACzB2B,WAASC,OAAsBxB,WAAWP,WAAUI,wBAAA,IAACD,UAAO,MAAMI,UAAUN,kBAAiBG,wBAAA,IAACD,UAAO;;AAGzG","ignoreList":[]}

package/dist/esm/function/avframe2VideoFrame.d.ts

@@ -0,0 +1,6 @@
+import AVFrame from "../struct/avframe";
+import { AVPixelFormat } from "../pixfmt";
+import { Rational } from "../struct/rational";
+export declare function avPixelFormat2Format(pixfmt: AVPixelFormat): "BGRA" | "I420" | "I420A" | "I422" | "I444" | "NV12" | "RGBA";
+export declare function getVideoColorSpaceInit(avframe: pointer<AVFrame>): VideoColorSpaceInit;
+export declare function avframe2VideoFrame(avframe: pointer<AVFrame>, timeBase?: Rational): VideoFrame;

package/dist/esm/function/avframe2VideoFrame.js

@@ -0,0 +1,117 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { PixelFormatDescriptorsMap } from "../pixelFormatDescriptor";
+
+import { avRescaleQ } from "../util/rational";
+
+import { AV_TIME_BASE_Q } from "../constant";
+
+import { getHeapU8 } from "@libmedia/cheap/heap";
+
+export function avPixelFormat2Format(pixfmt) {
+    switch (pixfmt) {
+      case 0:
+        return "I420";
+
+      case 33:
+        return "I420A";
+
+      case 4:
+        return "I422";
+
+      case 5:
+        return "I444";
+
+      case 28:
+        return "BGRA";
+
+      case 26:
+        return "RGBA";
+
+      case 23:
+        return "NV12";
+
+      default:
+        return null;
+    }
+}
+
+export function getVideoColorSpaceInit(avframe) {
+    const init = {
+        fullRange: !1,
+        matrix: null,
+        primaries: null,
+        transfer: null
+    };
+    switch (cheap__CTypeEnumRead__0[15](avframe + 220)) {
+      case 1:
+      default:
+        init.matrix = "bt709";
+        break;
+
+      case 6:
+        init.matrix = "smpte170m";
+        break;
+
+      case 5:
+        init.matrix = "bt470bg";
+        break;
+
+      case 0:
+        init.matrix = "rgb";
+    }
+    switch (cheap__CTypeEnumRead__0[15](avframe + 212)) {
+      case 1:
+      default:
+        init.primaries = "bt709";
+        break;
+
+      case 5:
+        init.primaries = "bt470bg";
+        break;
+
+      case 6:
+        init.primaries = "smpte170m";
+    }
+    switch (cheap__CTypeEnumRead__0[15](avframe + 216)) {
+      case 1:
+      default:
+        init.transfer = "bt709";
+        break;
+
+      case 13:
+        init.transfer = "iec61966-2-1";
+        break;
+
+      case 6:
+        init.transfer = "smpte170m";
+    }
+    return 2 === cheap__CTypeEnumRead__0[15](avframe + 208) && (init.fullRange = !0), 
+    init;
+}
+
+export function avframe2VideoFrame(avframe, timeBase) {
+    let height = cheap__CTypeEnumRead__0[15](avframe + 72);
+    const des = PixelFormatDescriptorsMap[cheap__CTypeEnumRead__0[15](avframe + 80)], layout = [];
+    for (let i = 0; i < des.nbComponents; i++) layout.push({
+        offset: cheap__CTypeEnumRead__0[20](avframe + 4 * i),
+        stride: cheap__CTypeEnumRead__0[15](avframe + 32 + 4 * i)
+    });
+    const init = {
+        codedWidth: cheap__CTypeEnumRead__0[15](avframe + 68),
+        codedHeight: height,
+        timestamp: Number(timeBase ? avRescaleQ(cheap__CTypeEnumRead__0[17](avframe + 104), timeBase, AV_TIME_BASE_Q) : cheap__CTypeEnumRead__0[17](avframe + 104)),
+        format: avPixelFormat2Format(cheap__CTypeEnumRead__0[15](avframe + 80)),
+        duration: Number(timeBase ? avRescaleQ(cheap__CTypeEnumRead__0[17](avframe + 312), timeBase, AV_TIME_BASE_Q) : cheap__CTypeEnumRead__0[17](avframe + 312)),
+        layout: layout,
+        colorSpace: getVideoColorSpaceInit(avframe),
+        visibleRect: {
+            x: cheap__CTypeEnumRead__0[15](avframe + 276),
+            y: cheap__CTypeEnumRead__0[15](avframe + 268),
+            width: cheap__CTypeEnumRead__0[15](avframe + 68) - (cheap__CTypeEnumRead__0[15](avframe + 276) + cheap__CTypeEnumRead__0[15](avframe + 280)),
+            height: cheap__CTypeEnumRead__0[15](avframe + 72) - (cheap__CTypeEnumRead__0[15](avframe + 268) + cheap__CTypeEnumRead__0[15](avframe + 272))
+        }
+    };
+    return new VideoFrame(getHeapU8(), init);
+}
+//# sourceMappingURL=avframe2VideoFrame.js.map

package/dist/esm/function/avframe2VideoFrame.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PixelFormatDescriptorsMap","avRescaleQ","AV_TIME_BASE_Q","getHeapU8","avPixelFormat2Format","pixfmt","getVideoColorSpaceInit","avframe","init","fullRange","matrix","primaries","transfer","cheap__CTypeEnumRead__0","avframe2VideoFrame","timeBase","height","des","layout","i","nbComponents","push","offset","stride","codedWidth","codedHeight","timestamp","Number","format","duration","colorSpace","visibleRect","x","y","width","VideoFrame"],"sources":["../../../function/avframe2VideoFrame.ts"],"mappings":";;SA0BSA,iCAA2B;;SAG3BC,kBAAY;;SACZC,sBAAgB;;SAChBC,iBAAW;;OAEd,SAAUC,qBAAqBC;IACnC,QAAQA;MACN;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;MACT;QACE,OAAO;;AAEb;;OAEM,SAAUC,uBAAuBC;IACrC,MAAMC,OAA4B;QAChCC,YAAW;QACXC,QAAQ;QACRC,WAAW;QACXC,UAAU;;IAGZ,QAAAC,wBAAA,IAAQN,UAAO;MACb;MAYA;QACEC,KAAKE,SAAS;QACd;;MAXF;QACEF,KAAKE,SAAS;QACd;;MACF;QACEF,KAAKE,SAAS;QACd;;MACF;QACEF,KAAKE,SAAS;;IAOlB,QAAAG,wBAAA,IAAQN,UAAO;MACb;MASA;QACEC,KAAKG,YAAY;QACjB;;MARF;QACEH,KAAKG,YAAY;QACjB;;MACF;QACEH,KAAKG,YAAY;;IAOrB,QAAAE,wBAAA,IAAQN,UAAO;MACb;MASA;QACEC,KAAKI,WAAW;QAChB;;MARF;QACEJ,KAAKI,WAAW;QAChB;;MACF;QACEJ,KAAKI,WAAW;;IAWpB,OAJW,MAAPC,wBAAA,IAAAN,UAAO,SACTC,KAAKC,aAAY;IAGZD;AACT;;OAEM,SAAUM,mBAAmBP,SAA2BQ;IAE5D,IAAIC,SAAMH,wBAAA,IAAGN,UAAO;IAEpB,MAAMU,MAAMjB,0BAA0Ba,wBAAA,IAAAN,UAAO,MAEvCW,SAAwB;IAE9B,KAAK,IAAIC,IAAI,GAAGA,IAAIF,IAAIG,cAAcD,KACpCD,OAAOG,KAAK;QACVC,QAAMT,wBAAA,IAAEN,UAAO;QACfgB,QAAMV,wBAAA,IAAEN,UAAO;;IAInB,MAAMC,OAA6B;QACjCgB,YAAUX,wBAAA,IAAEN,UAAO;QACnBkB,aAAaT;QACbU,WAASC,OAAsBZ,WAAWd,WAAUY,wBAAA,IAACN,UAAO,MAAMQ,UAAUb,kBAAiBW,wBAAA,IAACN,UAAO;QACrGqB,QAAQxB,qBAAoBS,wBAAA,IAACN,UAAO;QACpCsB,UAAQF,OAAsBZ,WAAWd,WAAUY,wBAAA,IAACN,UAAO,MAAWQ,UAAUb,kBAAiBW,wBAAA,IAACN,UAAO;QACzGW;QACAY,YAAYxB,uBAAuBC;QACnCwB,aAAa;YACXC,GAACnB,wBAAA,IAAEN,UAAO;YACV0B,GAACpB,wBAAA,IAAEN,UAAO;YACV2B,OAAOrB,wBAAA,IAAAN,UAAO,OAAUM,wBAAA,IAAAN,UAAO,OAAAM,wBAAA,IAAYN,UAAO;YAClDS,QAAQH,wBAAA,IAAAN,UAAO,OAAWM,wBAAA,IAAAN,UAAO,OAAAM,wBAAA,IAAWN,UAAO;;;IAIvD,OAAO,IAAI4B,WAAWhC,aAAaK;AACrC","ignoreList":[]}

package/dist/esm/function/avpacket2EncodedAudioChunk.d.ts

@@ -0,0 +1,2 @@
+import AVPacket from "../struct/avpacket";
+export default function avpacket2EncodedAudioChunk(avpacket: pointer<AVPacket>, pts?: int64): EncodedAudioChunk;

package/dist/esm/function/avpacket2EncodedAudioChunk.js

@@ -0,0 +1,13 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { mapUint8Array } from "@libmedia/cheap/std/memory";
+
+export default function avpacket2EncodedAudioChunk(avpacket, pts) {
+    const timestamp = Number(pts ?? cheap__CTypeEnumRead__0[17](avpacket + 8)), key = 1 & cheap__CTypeEnumRead__0[15](avpacket + 36);
+    return new EncodedAudioChunk({
+        type: key ? "key" : "delta",
+        timestamp: timestamp,
+        data: mapUint8Array(cheap__CTypeEnumRead__0[20](avpacket + 24), cheap__CTypeEnumRead__0[15](avpacket + 28))
+    });
+}
+//# sourceMappingURL=avpacket2EncodedAudioChunk.js.map

package/dist/esm/function/avpacket2EncodedAudioChunk.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["mapUint8Array","avpacket2EncodedAudioChunk","avpacket","pts","timestamp","Number","cheap__CTypeEnumRead__0","key","EncodedAudioChunk","type","data"],"sources":["../../../function/avpacket2EncodedAudioChunk.ts"],"mappings":";;SAyBSA,qBAAe;;eAEV,SAAUC,2BAA2BC,UAA6BC;IAC9E,MAAMC,YAASC,OAAuBF,OAAGG,wBAAA,IAAIJ,WAAQ,KAC/CK,MAAc,IAARD,wBAAA,IAAAJ,WAAQ;IACpB,OAAO,IAAIM,kBAAkB;QAC3BC,MAAMF,MAAM,QAAQ;QACpBH;QACAM,MAAMV,cAAaM,wBAAA,IAACJ,WAAQ,KAAAI,wBAAA,IAAOJ,WAAQ;;AAE/C","ignoreList":[]}

package/dist/esm/function/avpacket2EncodedVideoChunk.d.ts

@@ -0,0 +1,2 @@
+import AVPacket from "../struct/avpacket";
+export default function avpacket2EncodedVideoChunk(avpacket: pointer<AVPacket>, pts?: int64): EncodedVideoChunk;

package/dist/esm/function/avpacket2EncodedVideoChunk.js

@@ -0,0 +1,13 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { mapUint8Array } from "@libmedia/cheap/std/memory";
+
+export default function avpacket2EncodedVideoChunk(avpacket, pts) {
+    const timestamp = Number(pts ?? cheap__CTypeEnumRead__0[17](avpacket + 8)), key = 1 & cheap__CTypeEnumRead__0[15](avpacket + 36);
+    return new EncodedVideoChunk({
+        type: key ? "key" : "delta",
+        timestamp: timestamp,
+        data: mapUint8Array(cheap__CTypeEnumRead__0[20](avpacket + 24), cheap__CTypeEnumRead__0[15](avpacket + 28))
+    });
+}
+//# sourceMappingURL=avpacket2EncodedVideoChunk.js.map

package/dist/esm/function/avpacket2EncodedVideoChunk.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["mapUint8Array","avpacket2EncodedVideoChunk","avpacket","pts","timestamp","Number","cheap__CTypeEnumRead__0","key","EncodedVideoChunk","type","data"],"sources":["../../../function/avpacket2EncodedVideoChunk.ts"],"mappings":";;SAyBSA,qBAAe;;eAEV,SAAUC,2BAA2BC,UAA6BC;IAC9E,MAAMC,YAASC,OAAuBF,OAAGG,wBAAA,IAAIJ,WAAQ,KAC/CK,MAAc,IAARD,wBAAA,IAAAJ,WAAQ;IACpB,OAAO,IAAIM,kBAAkB;QAC3BC,MAAMF,MAAM,QAAQ;QACpBH;QACAM,MAAMV,cAAaM,wBAAA,IAACJ,WAAQ,KAAAI,wBAAA,IAAOJ,WAAQ;;AAE/C","ignoreList":[]}

package/dist/esm/function/compileResource.d.ts

@@ -0,0 +1,2 @@
+import { WebAssemblyResource } from "@libmedia/cheap/webassembly/compiler";
+export default function compileResource(wasmUrl: string | ArrayBuffer | WebAssemblyResource, thread?: boolean): Promise<WebAssemblyResource>;

package/dist/esm/function/compileResource.js

@@ -0,0 +1,17 @@
+import * as cheapConfig from "@libmedia/cheap/config";
+
+import compile from "@libmedia/cheap/webassembly/compiler";
+
+import * as is from "@libmedia/common/util/is";
+
+export default async function compileResource(wasmUrl, thread = !1) {
+    let resource;
+    return is.string(wasmUrl) || is.arrayBuffer(wasmUrl) ? (resource = await compile({
+        source: wasmUrl
+    }), cheapConfig.USE_THREADS && thread && (resource.threadModule = await compile({
+        source: resource.buffer
+    }, {
+        child: !0
+    })), delete resource.buffer) : resource = wasmUrl, resource;
+}
+//# sourceMappingURL=compileResource.js.map

package/dist/esm/function/compileResource.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["cheapConfig","compile","is","async","compileResource","wasmUrl","thread","resource","string","arrayBuffer","source","USE_THREADS","threadModule","buffer","child"],"sources":["../../../function/compileResource.ts"],"mappings":"YAwBYA,iBAAW;;OAChBC,aAAgC;;YAC3BC,QAAE;;eAECC,eAAeC,gBAAgBC,SAAqDC,UAAkB;IACnH,IAAIC;IAsBJ,OApBIL,GAAGM,OAAOH,YAAYH,GAAGO,YAAYJ,YACvCE,iBAAiBN,QAAQ;QACvBS,QAAQL;QAENL,YAAYW,eAA0CL,WACxDC,SAASK,qBAAqBX,QAC5B;QACES,QAAQH,SAASM;OAEnB;QACEC,QAAO;gBAINP,SAASM,UAGhBN,WAAWF,SAGNE;AACT","ignoreList":[]}

package/dist/esm/function/encodedAudioChunk2AVPacket.d.ts

@@ -0,0 +1,2 @@
+import AVPacket from "../struct/avpacket";
+export default function encodedAudioChunk2AVPacket(chunk: EncodedAudioChunk, avpacket?: pointer<AVPacket>, metadata?: EncodedAudioChunkMetadata): void;

package/dist/esm/function/encodedAudioChunk2AVPacket.js

@@ -0,0 +1,28 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { addAVPacketData, addAVPacketSideData, createAVPacket } from "../util/avpacket";
+
+import { avMalloc } from "../util/mem";
+
+import { mapUint8Array, memcpyFromUint8Array } from "@libmedia/cheap/std/memory";
+
+import { AV_TIME_BASE } from "../constant";
+
+export default function encodedAudioChunk2AVPacket(chunk, avpacket = 0, metadata) {
+    0 === avpacket && (avpacket = createAVPacket()), cheap__CTypeEnumWrite__1[17](avpacket + 8, BigInt(Math.floor(chunk.timestamp))), 
+    cheap__CTypeEnumWrite__1[17](avpacket + 16, BigInt(Math.floor(chunk.timestamp))), 
+    cheap__CTypeEnumWrite__1[17](avpacket + 48, BigInt(Math.floor(chunk.duration))), 
+    cheap__CTypeEnumWrite__1[15](avpacket + 76, AV_TIME_BASE), cheap__CTypeEnumWrite__1[15](avpacket + 72, 1), 
+    cheap__CTypeEnumWrite__1[15](avpacket + 36, 1 | cheap__CTypeEnumRead__0[15](avpacket + 36));
+    const data = avMalloc(chunk.byteLength);
+    if (chunk.copyTo(mapUint8Array(data, chunk.byteLength)), addAVPacketData(avpacket, data, chunk.byteLength), 
+    metadata && metadata.decoderConfig?.description) {
+        let buffer;
+        buffer = metadata.decoderConfig.description instanceof ArrayBuffer ? new Uint8Array(metadata.decoderConfig.description) : new Uint8Array(metadata.decoderConfig.description.buffer);
+        const extradata = avMalloc(buffer.length);
+        memcpyFromUint8Array(extradata, buffer.length, buffer), addAVPacketSideData(avpacket, 1, extradata, buffer.length);
+    }
+}
+//# sourceMappingURL=encodedAudioChunk2AVPacket.js.map

package/dist/esm/function/encodedAudioChunk2AVPacket.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["addAVPacketData","addAVPacketSideData","createAVPacket","avMalloc","mapUint8Array","memcpyFromUint8Array","AV_TIME_BASE","encodedAudioChunk2AVPacket","chunk","avpacket","metadata","cheap__CTypeEnumWrite__1","BigInt","Math","floor","timestamp","duration","cheap__CTypeEnumRead__0","data","byteLength","copyTo","decoderConfig","description","buffer","ArrayBuffer","Uint8Array","extradata","length"],"sources":["../../../function/encodedAudioChunk2AVPacket.ts"],"mappings":";;;;SAwBSA,iBAAiBC,qBAAqBC,sBAAgB;;SAEtDC,gBAAU;;SACVC,eAAeC,4BAAsB;;SACrCC,oBAAc;;eAGT,SAAUC,2BAA2BC,OAA0BC,WAAA,GAAuCC;IACtG,MAARD,aACFA,WAAWP,mBAGbS,yBAAA,IAAAF,WAAQ,GAAAG,OAAAC,KAAAC,MAAyCN,MAAMO;IAASJ,yBAAA,IAAjDF,WAAQ,IAAAG,OAAAC,KAAAC,MAA0BN,MAAMO;IACvDJ,yBAAA,IAAAF,WAAQ,IAAAG,OAAAC,KAAAC,MAA+BN,MAAMQ;IAC7CL,yBAAA,IAAAF,WAAQ,IAAgBH,eACxBK,yBAAA,IAAAF,WAAQ,IAAgB;IACxBE,yBAAA,IAAAF,WAAQ,QAAAQ,wBAAA,IAARR,WAAQ;IACR,MAAMS,OAAOf,SAASK,MAAMW;IAI5B,IAHAX,MAAMY,OAAOhB,cAAcc,MAAMV,MAAMW,cACvCnB,gBAAgBS,UAAUS,MAAMV,MAAMW;IAElCT,YACEA,SAASW,eAAeC,aAAa;QACvC,IAAIC;QAEFA,SADEb,SAASW,cAAcC,uBAAuBE,cACvC,IAAIC,WAAWf,SAASW,cAAcC,eAGtC,IAAIG,WAAWf,SAASW,cAAcC,YAAYC;QAE7D,MAAMG,YAAYvB,SAASoB,OAAOI;QAClCtB,qBAAqBqB,WAAWH,OAAOI,QAAQJ,SAC/CtB,oBAAoBQ,UAAQ,GAAkDiB,WAAWH,OAAOI;AAClG;AAEJ","ignoreList":[]}

package/dist/esm/function/encodedVideoChunk2AVPacket.d.ts

@@ -0,0 +1,7 @@
+import AVPacket from "../struct/avpacket";
+export default function encodedVideoChunk2AVPacket(chunk: EncodedVideoChunk, avpacket?: pointer<AVPacket>, metadata?: EncodedVideoChunkMetadata & {
+    svc?: {
+        temporalLayerId: number;
+    };
+    alphaSideData?: BufferSource;
+}): void;

package/dist/esm/function/encodedVideoChunk2AVPacket.js

@@ -0,0 +1,35 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { addAVPacketData, addAVPacketSideData, createAVPacket } from "../util/avpacket";
+
+import { avMalloc } from "../util/mem";
+
+import { mapUint8Array, memcpyFromUint8Array } from "@libmedia/cheap/std/memory";
+
+import { AV_TIME_BASE } from "../constant";
+
+export default function encodedVideoChunk2AVPacket(chunk, avpacket = 0, metadata) {
+    0 === avpacket && (avpacket = createAVPacket()), cheap__CTypeEnumWrite__1[17](avpacket + 8, BigInt(Math.floor(chunk.timestamp))), 
+    cheap__CTypeEnumWrite__1[15](avpacket + 76, AV_TIME_BASE), cheap__CTypeEnumWrite__1[15](avpacket + 72, 1), 
+    cheap__CTypeEnumWrite__1[17](avpacket + 48, BigInt(Math.floor(chunk.duration)));
+    const data = avMalloc(chunk.byteLength);
+    if (chunk.copyTo(mapUint8Array(data, chunk.byteLength)), addAVPacketData(avpacket, data, chunk.byteLength), 
+    metadata) {
+        if (metadata.decoderConfig?.description) {
+            let buffer;
+            buffer = metadata.decoderConfig.description instanceof ArrayBuffer ? new Uint8Array(metadata.decoderConfig.description) : new Uint8Array(metadata.decoderConfig.description.buffer);
+            const extradata = avMalloc(buffer.length);
+            memcpyFromUint8Array(extradata, buffer.length, buffer), addAVPacketSideData(avpacket, 1, extradata, buffer.length);
+        }
+        if (metadata.alphaSideData) {
+            const extradata = avMalloc(metadata.alphaSideData.byteLength);
+            let buffer;
+            buffer = metadata.alphaSideData instanceof ArrayBuffer ? new Uint8Array(metadata.alphaSideData) : new Uint8Array(metadata.alphaSideData.buffer), 
+            memcpyFromUint8Array(extradata, buffer.length, buffer), addAVPacketSideData(avpacket, 15, extradata, buffer.length);
+        }
+    }
+    "key" === chunk.type && cheap__CTypeEnumWrite__1[15](avpacket + 36, 1 | cheap__CTypeEnumRead__0[15](avpacket + 36));
+}
+//# sourceMappingURL=encodedVideoChunk2AVPacket.js.map

package/dist/esm/function/encodedVideoChunk2AVPacket.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["addAVPacketData","addAVPacketSideData","createAVPacket","avMalloc","mapUint8Array","memcpyFromUint8Array","AV_TIME_BASE","encodedVideoChunk2AVPacket","chunk","avpacket","metadata","cheap__CTypeEnumWrite__1","BigInt","Math","floor","timestamp","duration","data","byteLength","copyTo","decoderConfig","description","buffer","ArrayBuffer","Uint8Array","extradata","length","alphaSideData","type","cheap__CTypeEnumRead__0"],"sources":["../../../function/encodedVideoChunk2AVPacket.ts"],"mappings":";;;;SAwBSA,iBAAiBC,qBAAqBC,sBAAgB;;SAEtDC,gBAAU;;SACVC,eAAeC,4BAAsB;;SACrCC,oBAAc;;eAGT,SAAUC,2BAA2BC,OAA0BC,WAAA,GAAuCC;IAMtG,MAARD,aACFA,WAAWP,mBAGbS,yBAAA,IAAAF,WAAQ,GAAAG,OAAAC,KAAAC,MAA0BN,MAAMO;IACxCJ,yBAAA,IAAAF,WAAQ,IAAgBH,eACxBK,yBAAA,IAAAF,WAAQ,IAAgB;IACxBE,yBAAA,IAAAF,WAAQ,IAAAG,OAAAC,KAAAC,MAA+BN,MAAMQ;IAC7C,MAAMC,OAAOd,SAASK,MAAMU;IAK5B,IAJAV,MAAMW,OAAOf,cAAca,MAAMT,MAAMU,cAEvClB,gBAAgBS,UAAUQ,MAAMT,MAAMU;IAElCR,UAAU;QACZ,IAAIA,SAASU,eAAeC,aAAa;YACvC,IAAIC;YAEFA,SADEZ,SAASU,cAAcC,uBAAuBE,cACvC,IAAIC,WAAWd,SAASU,cAAcC,eAGtC,IAAIG,WAAWd,SAASU,cAAcC,YAAYC;YAE7D,MAAMG,YAAYtB,SAASmB,OAAOI;YAClCrB,qBAAqBoB,WAAWH,OAAOI,QAAQJ,SAC/CrB,oBAAoBQ,UAAQ,GAAkDgB,WAAWH,OAAOI;AAClG;QACA,IAAIhB,SAASiB,eAAe;YAC1B,MAAMF,YAAYtB,SAASO,SAASiB,cAAcT;YAClD,IAAII;YAEFA,SADEZ,SAASiB,yBAAyBJ,cAC3B,IAAIC,WAAWd,SAASiB,iBAGxB,IAAIH,WAAWd,SAASiB,cAAcL;YAEjDjB,qBAAqBoB,WAAWH,OAAOI,QAAQJ,SAC/CrB,oBAAoBQ,UAAQ,IAA6DgB,WAAWH,OAAOI;AAC7G;AACF;IAEmB,UAAflB,MAAMoB,QACRjB,yBAAA,IAAAF,WAAQ,QAAAoB,wBAAA,IAARpB,WAAQ;AAEZ","ignoreList":[]}

package/dist/esm/function/getAudioCodec.d.ts

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

package/dist/esm/function/getAudioCodec.js

@@ -0,0 +1,10 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CodecId2MimeType } from "../stringEnum";
+
+export default function getAudioCodec(codecpar) {
+    const codecId = cheap__CTypeEnumRead__0[15](codecpar + 4);
+    let profile = cheap__CTypeEnumRead__0[15](codecpar + 48), codec = CodecId2MimeType[codecId];
+    return 86018 === codecId && (codec = `${codec}.${profile}`), codec || "unknown";
+}
+//# sourceMappingURL=getAudioCodec.js.map

package/dist/esm/function/getAudioCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CodecId2MimeType","getAudioCodec","codecpar","codecId","cheap__CTypeEnumRead__0","profile","codec"],"sources":["../../../function/getAudioCodec.ts"],"mappings":";;SA0BSA,wBAAkB;;eAGb,SAAUC,cAAcC;IAEpC,MAAMC,UAAOC,wBAAA,IAAGF,WAAQ;IACxB,IAAIG,UAAOD,wBAAA,IAAGF,WAAQ,KAElBI,QAAQN,iBAAiBG;IAS7B,OAPW,UAAPA,YAKFG,QAAQ,GAAGA,SAASD,YAEfC,SAAS;AAClB","ignoreList":[]}

package/dist/esm/function/getHardwarePreference.d.ts

@@ -0,0 +1 @@
+export declare function getHardwarePreference(enable: boolean): HardwareAcceleration;

package/dist/esm/function/getHardwarePreference.js

@@ -0,0 +1,6 @@
+import browser from "@libmedia/common/util/browser";
+
+export function getHardwarePreference(enable) {
+    return enable ? !browser.chrome || browser.checkVersion(browser.majorVersion, "94", !0) ? "prefer-hardware" : "allow" : !browser.chrome || browser.checkVersion(browser.majorVersion, "94", !0) ? "prefer-software" : "deny";
+}
+//# sourceMappingURL=getHardwarePreference.js.map

package/dist/esm/function/getHardwarePreference.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["browser","getHardwarePreference","enable","chrome","checkVersion","majorVersion"],"sources":["../../../function/getHardwarePreference.ts"],"mappings":"OAyBOA,aAAO;;OAER,SAAUC,sBAAsBC;IACpC,OAAIA,UACGF,QAAQG,UAAUH,QAAQI,aAAaJ,QAAQK,cAAc,OAAM,KAC/D,oBAGA,WAIJL,QAAQG,UAAUH,QAAQI,aAAaJ,QAAQK,cAAc,OAAM,KAC/D,oBAGA;AAGb","ignoreList":[]}

package/dist/esm/function/getVideoCodec.d.ts

@@ -0,0 +1,2 @@
+import AVCodecParameters from "../struct/avcodecparameters";
+export default function getVideoCodec(codecpar: pointer<AVCodecParameters>, extradata?: Uint8Array): string;

package/dist/esm/function/getVideoCodec.js

@@ -0,0 +1,64 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CodecId2MimeType } from "../stringEnum";
+
+import * as av1 from "../codecs/av1";
+
+import * as vp8 from "../codecs/vp8";
+
+import * as vp9 from "../codecs/vp9";
+
+import * as vvc from "../codecs/vvc";
+
+import * as string from "@libmedia/common/util/string";
+
+import { NOPTS_VALUE } from "../constant";
+
+import { mapUint8Array } from "@libmedia/cheap/std/memory";
+
+import * as base32 from "@libmedia/common/util/base32";
+
+export default function getVideoCodec(codecpar, extradata) {
+    const codecId = cheap__CTypeEnumRead__0[15](codecpar + 4);
+    let profile = cheap__CTypeEnumRead__0[15](codecpar + 48), level = cheap__CTypeEnumRead__0[15](codecpar + 52);
+    !extradata && 0 !== cheap__CTypeEnumRead__0[20](codecpar + 12) && cheap__CTypeEnumRead__0[15](codecpar + 16) && (extradata = mapUint8Array(cheap__CTypeEnumRead__0[20](codecpar + 12), cheap__CTypeEnumRead__0[15](codecpar + 16)));
+    let entry = 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 !== NOPTS_VALUE && level !== 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 !== NOPTS_VALUE && level !== 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;
+}
+//# sourceMappingURL=getVideoCodec.js.map

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

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

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

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

package/dist/esm/function/hasAlphaChannel.js

@@ -0,0 +1,10 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { PixelFormatDescriptorsMap } from "../pixelFormatDescriptor";
+
+export default function hasAlphaChannel(parameters) {
+    if (0 !== cheap__CTypeEnumRead__0[15](parameters)) return !1;
+    const descriptor = PixelFormatDescriptorsMap[cheap__CTypeEnumRead__0[15](parameters + 28)];
+    return descriptor && 128 & descriptor.flags;
+}
+//# sourceMappingURL=hasAlphaChannel.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["PixelFormatDescriptorsMap","hasAlphaChannel","parameters","cheap__CTypeEnumRead__0","descriptor","flags"],"sources":["../../../function/hasAlphaChannel.ts"],"mappings":";;SAyBSA,iCAA6C;;eAIxC,SAAUC,gBAAgBC;IACtC,IAAc,MAAVC,wBAAA,IAAAD,aACF,QAAO;IAET,MAAME,aAAaJ,0BAAyBG,wBAAA,IAACD,aAAU;IACvD,OAAOE,cAA+B,MAAhBA,WAAWC;AACnC","ignoreList":[]}

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

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

package/dist/esm/function/isHdr.js

@@ -0,0 +1,10 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { PixelFormatDescriptorsMap } from "../pixelFormatDescriptor";
+
+export default function isHdr(parameters) {
+    if (0 !== cheap__CTypeEnumRead__0[15](parameters)) return !1;
+    const descriptor = PixelFormatDescriptorsMap[cheap__CTypeEnumRead__0[15](parameters + 28)];
+    return !(!descriptor || descriptor.comp[0].depth <= 8) && (18 === cheap__CTypeEnumRead__0[15](parameters + 92) || 16 === cheap__CTypeEnumRead__0[15](parameters + 92));
+}
+//# sourceMappingURL=isHdr.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["PixelFormatDescriptorsMap","isHdr","parameters","cheap__CTypeEnumRead__0","descriptor","comp","depth"],"sources":["../../../function/isHdr.ts"],"mappings":";;SAyBSA,iCAA2B;;eAKtB,SAAUC,MAAMC;IAC5B,IAAc,MAAVC,wBAAA,IAAAD,aACF,QAAO;IAGT,MAAME,aAAaJ,0BAAyBG,wBAAA,IAACD,aAAU;IACvD,UAAKE,cAAcA,WAAWC,KAAK,GAAGC,SAAS,OAI9B,OAAVH,wBAAA,IAAAD,aAAU,OACF,OAAVC,wBAAA,IAAAD,aAAU;AACjB","ignoreList":[]}