@libmedia/avutil 0.2.0

package/dist/esm/util/pixel.js

@@ -0,0 +1,180 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { PixelFormatDescriptorsMap } from "../pixelFormatDescriptor";
+
+import * as errorType from "../error";
+
+import { INT32_MAX } from "../constant";
+
+import { memset } from "@libmedia/cheap/std/memory";
+
+import * as stack from "@libmedia/cheap/stack";
+
+import { avFree, avMalloc } from "./mem";
+
+import alignFunc from "@libmedia/common/math/align";
+
+export function chromaLocation2Pos(pos) {
+    if (!(pos <= 0 || pos >= 7)) return {
+        x: 128 * (1 & pos),
+        y: 128 * (pos >>> 1 ^ (pos < 4 ? 1 : 0))
+    };
+}
+
+function getMaxPixSteps(desc) {
+    const maxPixSteps = [ 0, 0, 0, 0 ], maxPixStepsComps = [ 0, 0, 0, 0 ];
+    for (let i = 0; i < 4; i++) desc.comp[i] && desc.comp[i].step > maxPixSteps[desc.comp[i].plane] && (maxPixSteps[desc.comp[i].plane] = desc.comp[i].step, 
+    maxPixStepsComps[desc.comp[i].plane] = i);
+    return {
+        maxPixSteps: maxPixSteps,
+        maxPixStepsComps: maxPixStepsComps
+    };
+}
+
+function pixelGetLinesize_(width, plane, maxStep, maxStepComp, desc) {
+    if (!desc) return errorType.INVALID_ARGUMENT;
+    if (width < 0) return errorType.INVALID_ARGUMENT;
+    const s = 1 === maxStepComp || 2 === maxStepComp ? desc.log2ChromaW : 0, shiftedW = width + (1 << s) - 1 >>> s;
+    if (shiftedW && maxStep > INT32_MAX / shiftedW) return errorType.INVALID_ARGUMENT;
+    let linesize = maxStep * shiftedW;
+    return 4 & desc.flags && (linesize = linesize + 7 >>> 3), linesize;
+}
+
+export function pixelGetLinesize(pixfmt, width, plane) {
+    const desc = PixelFormatDescriptorsMap[pixfmt];
+    if (!desc) return errorType.INVALID_ARGUMENT;
+    const {maxPixSteps: maxPixSteps, maxPixStepsComps: maxPixStepsComps} = getMaxPixSteps(desc);
+    return pixelGetLinesize_(width, 0, maxPixSteps[plane], maxPixStepsComps[plane], desc);
+}
+
+export function pixelFillLinesizes(linesizes, pixfmt, width) {
+    const desc = PixelFormatDescriptorsMap[pixfmt];
+    if (!desc) return errorType.INVALID_ARGUMENT;
+    const {maxPixSteps: maxPixSteps, maxPixStepsComps: maxPixStepsComps} = getMaxPixSteps(desc);
+    memset(linesizes, 0, 16);
+    let ret = 0;
+    for (let i = 0; i < 4; i++) {
+        if ((ret = pixelGetLinesize_(width, 0, maxPixSteps[i], maxPixStepsComps[i], desc)) < 0) return ret;
+        cheap__CTypeEnumWrite__1[15](linesizes + 4 * i, ret);
+    }
+}
+
+export function pixelFillPlaneSizes(sizes, pixfmt, height, linesizes) {
+    const hasPlane = [ 0, 0, 0, 0 ], desc = PixelFormatDescriptorsMap[pixfmt];
+    if (!desc) return errorType.INVALID_ARGUMENT;
+    if (memset(sizes, 0, 16), cheap__CTypeEnumRead__0[15](linesizes) > INT32_MAX / height) return errorType.INVALID_ARGUMENT;
+    if (cheap__CTypeEnumWrite__1[15](sizes, cheap__CTypeEnumRead__0[15](linesizes) * height), 
+    2 & desc.flags) return cheap__CTypeEnumWrite__1[15](sizes + 4, 1024), 0;
+    for (let i = 0; i < 4; i++) desc.comp[i] && (hasPlane[desc.comp[i].plane] = 1);
+    for (let i = 0; i < 4 && hasPlane[i]; i++) {
+        let s = 1 === i || 2 === i ? desc.log2ChromaH : 0, h = height + (1 << s) - 1 >> s;
+        if (cheap__CTypeEnumRead__0[15](linesizes + 4 * i) > INT32_MAX / h) return errorType.INVALID_ARGUMENT;
+        cheap__CTypeEnumWrite__1[15](sizes + 4 * i, h * cheap__CTypeEnumRead__0[15](linesizes + 4 * i));
+    }
+    return 0;
+}
+
+export function pixelFillPointer(data, pixfmt, height, ptr, linesizes) {
+    const linesizes1 = stack.malloc(16), sizes = stack.malloc(16);
+    memset(data, 0, 16);
+    for (let i = 0; i < 4; i++) cheap__CTypeEnumWrite__1[15](linesizes1 + 4 * i, cheap__CTypeEnumRead__0[15](linesizes + 4 * i));
+    let ret = pixelFillPlaneSizes(sizes, pixfmt, height, linesizes1);
+    if (ret < 0) return defer(), ret;
+    ret = 0;
+    for (let i = 0; i < 4; i++) {
+        if (cheap__CTypeEnumRead__0[15](sizes + 4 * i) > INT32_MAX - ret) return defer(), 
+        errorType.INVALID_ARGUMENT;
+        ret += cheap__CTypeEnumRead__0[15](sizes + 4 * i);
+    }
+    if (!ptr) return defer(), ret;
+    cheap__CTypeEnumWrite__1[20](data, ptr);
+    for (let i = 1; i < 4 && cheap__CTypeEnumRead__0[15](sizes + 4 * i); i++) cheap__CTypeEnumWrite__1[20](data + 4 * i, cheap__CTypeEnumRead__0[20](data + (i - 1)) + cheap__CTypeEnumRead__0[15](sizes + (i - 1)));
+    return defer(), ret;
+    function defer() {
+        stack.free(16), stack.free(16);
+    }
+}
+
+export function pixelAlloc(pointers, linesizes, w, h, pixfmt, align = 1) {
+    const desc = PixelFormatDescriptorsMap[pixfmt];
+    if (!desc) return errorType.INVALID_ARGUMENT;
+    const linesizes1 = stack.malloc(16), sizes = stack.malloc(16);
+    let ret = 0;
+    if ((ret = pixelFillLinesizes(linesizes, pixfmt, align > 7 ? alignFunc(w, 8) : w)) < 0) return defer(), 
+    ret;
+    for (let i = 0; i < 4; i++) cheap__CTypeEnumWrite__1[15](linesizes + 4 * i, alignFunc(cheap__CTypeEnumRead__0[15](linesizes + 4 * i), align)), 
+    cheap__CTypeEnumWrite__1[15](linesizes1 + 4 * i, cheap__CTypeEnumRead__0[15](linesizes + 4 * i));
+    if ((ret = pixelFillPlaneSizes(sizes, pixfmt, h, linesizes1)) < 0) return defer(), 
+    ret;
+    let totalSize = align;
+    for (let i = 0; i < 4; i++) {
+        if (totalSize > INT32_MAX - cheap__CTypeEnumRead__0[15](sizes + 4 * i)) return defer(), 
+        errorType.INVALID_ARGUMENT;
+        totalSize += cheap__CTypeEnumRead__0[15](sizes + 4 * i);
+    }
+    const buf = avMalloc(totalSize);
+    if (!buf) return defer(), errorType.NO_MEMORY;
+    if ((ret = pixelFillPointer(pointers, pixfmt, h, buf, linesizes)) < 0) return defer(), 
+    ret;
+    if (2 & desc.flags) {
+        if (align < 4) return avFree(buf), defer(), ret;
+        !function(pal, pixfmt) {
+            for (let i = 0; i < 256; i++) {
+                let r, g, b;
+                switch (pixfmt) {
+                  case 20:
+                    r = 36 * (i >> 5), g = 36 * (i >> 2 & 7), b = 85 * (3 & i);
+                    break;
+
+                  case 17:
+                    b = 85 * (i >> 6), g = 36 * (i >> 3 & 7), r = 36 * (7 & i);
+                    break;
+
+                  case 22:
+                    r = 255 * (i >> 3), g = 85 * (i >> 1 & 3), b = 255 * (1 & i);
+                    break;
+
+                  case 19:
+                    b = 255 * (i >> 3), g = 85 * (i >> 1 & 3), r = 255 * (1 & i);
+                    break;
+
+                  case 8:
+                    r = b = g = i;
+                    break;
+
+                  default:
+                    return errorType.INVALID_ARGUMENT;
+                }
+                cheap__CTypeEnumWrite__1[8](pal + 4 * i, b + (g << 8) + (r << 16) + -16777216);
+            }
+        }(cheap__CTypeEnumRead__0[20](pointers + 4), pixfmt);
+    }
+    return 2 & desc.flags && cheap__CTypeEnumRead__0[20](pointers + 4) && cheap__CTypeEnumRead__0[20](pointers + 4) - cheap__CTypeEnumRead__0[20](pointers) > cheap__CTypeEnumRead__0[15](linesizes) * h && memset(cheap__CTypeEnumRead__0[20](pointers) + cheap__CTypeEnumRead__0[15](linesizes) * h, 0, cheap__CTypeEnumRead__0[20](pointers + 4) - cheap__CTypeEnumRead__0[20](pointers) - cheap__CTypeEnumRead__0[15](linesizes) * h), 
+    defer(), ret;
+    function defer() {
+        stack.free(16), stack.free(16);
+    }
+}
+
+export function pixelGetSize(pixfmt, width, height, align) {
+    if (!PixelFormatDescriptorsMap[pixfmt]) return errorType.INVALID_ARGUMENT;
+    const linesizes = stack.malloc(16), alignedLinesizes = stack.malloc(16), sizes = stack.malloc(16);
+    let ret = 0;
+    if ((ret = pixelFillLinesizes(linesizes, pixfmt, width)) < 0) return defer(), ret;
+    for (let i = 0; i < 4; i++) cheap__CTypeEnumWrite__1[15](alignedLinesizes + 4 * i, alignFunc(cheap__CTypeEnumRead__0[15](linesizes + 4 * i), align));
+    if ((ret = pixelFillPlaneSizes(sizes, pixfmt, height, alignedLinesizes)) < 0) return defer(), 
+    ret;
+    let totalSize = 0;
+    for (let i = 0; i < 4; i++) {
+        if (totalSize > INT32_MAX - cheap__CTypeEnumRead__0[15](sizes + 4 * i)) return defer(), 
+        errorType.INVALID_ARGUMENT;
+        totalSize += cheap__CTypeEnumRead__0[15](sizes + 4 * i);
+    }
+    return defer(), totalSize;
+    function defer() {
+        stack.free(16), stack.free(16), stack.free(16);
+    }
+}
+//# sourceMappingURL=pixel.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["PixelFormatDescriptorsMap","errorType","INT32_MAX","memset","stack","avFree","avMalloc","alignFunc","chromaLocation2Pos","pos","x","y","getMaxPixSteps","desc","maxPixSteps","maxPixStepsComps","i","comp","step","plane","pixelGetLinesize_","width","maxStep","maxStepComp","INVALID_ARGUMENT","s","log2ChromaW","shiftedW","linesize","flags","pixelGetLinesize","pixfmt","pixelFillLinesizes","linesizes","ret","cheap__CTypeEnumWrite__1","pixelFillPlaneSizes","sizes","height","hasPlane","cheap__CTypeEnumRead__0","log2ChromaH","h","pixelFillPointer","data","ptr","linesizes1","malloc","defer","free","pixelAlloc","pointers","w","align","totalSize","buf","NO_MEMORY","pal","r","g","b","setSystematicPal","pixelGetSize","alignedLinesizes"],"sources":["../../../util/pixel.ts"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,41 @@
+import { Rational } from "../struct/rational";
+/**
+ * 将一个时间戳由一个时间基转换到另一个时间基
+ *
+ * @param a 待转换时间戳
+ * @param bp 待转换时间戳的时间基
+ * @param cq 目标时间基
+ */
+export declare function avRescaleQ(a: int64, bq: Rational, cq: Rational): bigint;
+/**
+ * 将一个时间戳由一个时间基转换到另一个时间基
+ *
+ * @param a 待转换时间戳
+ * @param bp 待转换时间戳的时间基
+ * @param cq 目标时间基
+ */
+export declare function avRescaleQ2(a: int64, bq: pointer<Rational>, cq: pointer<Rational>): bigint;
+/**
+ * 将一个时间基转换成 double
+ *
+ * @param a
+ */
+export declare function avQ2D(a: Rational): number;
+/**
+ * 将一个时间基转换成 double
+ *
+ * @param a
+ */
+export declare function avQ2D2(a: pointer<Rational>): number;
+/**
+ * 化简 Rational
+ *
+ * @param a
+ */
+export declare function avReduce(a: Rational): void;
+/**
+ * 化简 Rational
+ *
+ * @param a
+ */
+export declare function avReduce2(a: pointer<Rational>): void;

package/dist/esm/util/rational.js

@@ -0,0 +1,33 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__10 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import gcd from "@libmedia/common/math/gcd";
+
+export function avRescaleQ(a, bq, cq) {
+    return a * BigInt(bq.num | 0) * BigInt(cq.den | 0) / (BigInt(bq.den | 0) * BigInt(cq.num | 0));
+}
+
+export function avRescaleQ2(a, bq, cq) {
+    return a * BigInt(cheap__CTypeEnumRead__0[15](bq) | 0) * BigInt(cheap__CTypeEnumRead__0[15](cq + 4) | 0) / (BigInt(cheap__CTypeEnumRead__0[15](bq + 4) | 0) * BigInt(cheap__CTypeEnumRead__0[15](cq) | 0));
+}
+
+export function avQ2D(a) {
+    return a.num / a.den;
+}
+
+export function avQ2D2(a) {
+    return cheap__CTypeEnumRead__0[15](a) / cheap__CTypeEnumRead__0[15](a + 4);
+}
+
+export function avReduce(a) {
+    const gcdValue = gcd(a.num, a.den);
+    gcdValue <= 1 || (a.den /= gcdValue, a.num /= gcdValue);
+}
+
+export function avReduce2(a) {
+    const gcdValue = gcd(cheap__CTypeEnumRead__0[15](a), cheap__CTypeEnumRead__0[15](a + 4));
+    gcdValue <= 1 || (cheap__CTypeEnumWrite__10[15](a + 4, cheap__CTypeEnumRead__0[15](a + 4) / gcdValue), 
+    cheap__CTypeEnumWrite__10[15](a, cheap__CTypeEnumRead__0[15](a) / gcdValue));
+}
+//# sourceMappingURL=rational.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["gcd","avRescaleQ","a","bq","cq","BigInt","num","den","avRescaleQ2","cheap__CTypeEnumRead__0","avQ2D","avQ2D2","avReduce","gcdValue","avReduce2","cheap__CTypeEnumWrite__10"],"sources":["../../../util/rational.ts"],"mappings":";;;;OA0BOA,SAAG;;OASJ,SAAUC,WAAWC,GAAUC,IAAcC;IAGjD,OAFUF,IAACG,OAAsBF,GAAGG,MAAG,KAACD,OAAsBD,GAAGG,MAAG,MAC1DF,OAAmBF,GAAGI,MAAG,KAAAF,OAAuBD,GAAGE,MAAG;AAElE;;OASM,SAAUE,YAAYN,GAAUC,IAAuBC;IAG3D,OAFUF,IAACG,OAAAI,wBAAA,IAAsBN,MAAE,KAAKE,OAAAI,wBAAA,IAAsBL,KAAE,WACtDC,OAAAI,wBAAA,IAAmBN,KAAE,UAAAE,OAAAI,wBAAA,IAA2BL,MAAE;AAE9D;;OAOM,SAAUM,MAAMR;IACpB,OAAOA,EAAEI,MAAMJ,EAAEK;AACnB;;OAOM,SAAUI,OAAOT;IACrB,OAAOO,wBAAA,IAAAP,KAACO,wBAAA,IAAOP,IAAC;AAClB;;OAOM,SAAUU,SAASV;IACvB,MAAMW,WAAWb,IAAIE,EAAEI,KAAKJ,EAAEK;IAC1BM,YAAY,MAGhBX,EAAEK,OAAOM,UACTX,EAAEI,OAAOO;AACX;;OAOM,SAAUC,UAAUZ;IACxB,MAAMW,WAAWb,IAAGS,wBAAA,IAACP,IAACO,wBAAA,IAAMP,IAAC;IACzBW,YAAY,MAGhBE,0BAAA,IAAAb,IAAC,GAAAO,wBAAA,IAADP,IAAC,KAAQW;IACTE,0BAAA,IAAAb,GAACO,wBAAA,IAADP,KAASW;AACX","ignoreList":[]}

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

@@ -0,0 +1,7 @@
+import { AVSampleFormat } from "../audiosamplefmt";
+export declare function getBytesPerSample(format: AVSampleFormat): number;
+export declare function sampleFormatIsPlanar(format: AVSampleFormat): boolean;
+export declare function sampleFormatGetLinesize(format: AVSampleFormat, channels: int32, nbSamples: int32, align?: int32): number;
+export declare function sampleFillArrays(audioData: pointer<pointer<uint8>>, buf: pointer<uint8>, format: AVSampleFormat, linesize: int32, channels: int32): 0 | -1;
+export declare function sampleAlloc(audioData: pointer<pointer<uint8>>, format: AVSampleFormat, linesize: int32, channels: int32): number;
+export declare function sampleSetSilence(audioData: pointer<pointer<uint8>>, offset: int32, format: AVSampleFormat, nbSamples: int32, channels: int32): void;

package/dist/esm/util/sample.js

@@ -0,0 +1,48 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { memset } from "@libmedia/cheap/std/memory";
+
+import { INT32_MAX } from "../constant";
+
+import alignFunc from "@libmedia/common/math/align";
+
+import { avFree, avMalloc } from "../util/mem";
+
+import { AVSampleFormatDescriptors } from "../sampleFormatDescriptor";
+
+export function getBytesPerSample(format) {
+    return format < 0 || format >= 12 ? 0 : AVSampleFormatDescriptors[format].bits >> 3;
+}
+
+export function sampleFormatIsPlanar(format) {
+    return !(format < 0 || format >= 12) && AVSampleFormatDescriptors[format].planar;
+}
+
+export function sampleFormatGetLinesize(format, channels, nbSamples, align) {
+    const sampleSize = getBytesPerSample(format), planar = sampleFormatIsPlanar(format);
+    return !sampleSize || nbSamples <= 0 || channels <= 0 ? -1 : (align || (align = 1, 
+    nbSamples = alignFunc(nbSamples, 32)), channels > INT32_MAX / align || channels * nbSamples > (INT32_MAX - align * channels) / sampleSize ? -1 : alignFunc(planar ? nbSamples * sampleSize : nbSamples * sampleSize * channels, align));
+}
+
+export function sampleFillArrays(audioData, buf, format, linesize, channels) {
+    const planar = sampleFormatIsPlanar(format);
+    if (memset(audioData, 0, planar ? 4 * channels : 4), !buf) return -1;
+    if (cheap__CTypeEnumWrite__1[20](audioData, buf), planar) for (let i = 1; i < channels; i++) cheap__CTypeEnumWrite__1[20](audioData + 4 * i, cheap__CTypeEnumRead__0[20](audioData + (i - 1)) + linesize);
+    return 0;
+}
+
+export function sampleAlloc(audioData, format, linesize, channels) {
+    const bufSize = sampleFormatIsPlanar(format) ? linesize * channels : linesize;
+    if (bufSize < 0) return bufSize;
+    const buf = avMalloc(bufSize), ret = sampleFillArrays(audioData, buf, format, linesize, channels);
+    return ret < 0 ? (avFree(buf), ret) : 0;
+}
+
+export function sampleSetSilence(audioData, offset, format, nbSamples, channels) {
+    const planar = sampleFormatIsPlanar(format), planes = planar ? channels : 1, blockAlign = getBytesPerSample(format) * (planar ? 1 : channels), dataSize = nbSamples * blockAlign, fillChar = 0 === format || 5 === format ? 128 : 0;
+    offset *= blockAlign;
+    for (let i = 0; i < planes; i++) memset(cheap__CTypeEnumRead__0[20](audioData + 4 * i) + offset, fillChar, dataSize);
+}
+//# sourceMappingURL=sample.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["memset","INT32_MAX","alignFunc","avFree","avMalloc","AVSampleFormatDescriptors","getBytesPerSample","format","bits","sampleFormatIsPlanar","planar","sampleFormatGetLinesize","channels","nbSamples","align","sampleSize","sampleFillArrays","audioData","buf","linesize","cheap__CTypeEnumWrite__1","i","cheap__CTypeEnumRead__0","sampleAlloc","bufSize","ret","sampleSetSilence","offset","planes","blockAlign","dataSize","fillChar"],"sources":["../../../util/sample.ts"],"mappings":";;;;SAyBSA,cAAQ;;SAERC,iBAAW;;OACbC,eAAS;;SACPC,QAAQC,gBAAU;;SAClBC,iCAA2B;;OAE9B,SAAUC,kBAAkBC;IAChC,OAAQA,SAAS,KAAKA,UAAM,KACxB,IACAF,0BAA0BE,QAAQC,QAAQ;AAChD;;OAEM,SAAUC,qBAAqBF;IACnC,SAAQA,SAAS,KAAKA,UAAM,OAExBF,0BAA0BE,QAAQG;AACxC;;OAEM,SAAUC,wBAAwBJ,QAAwBK,UAAiBC,WAAkBC;IACjG,MAAMC,aAAaT,kBAAkBC,SAC/BG,SAASD,qBAAqBF;IAEpC,QAAKQ,cAAcF,aAAa,KAAKD,YAAY,KACvC,KAGLE,UACHA,QAAQ;IACRD,YAAYX,UAAUW,WAAW,MAG/BD,WAAWX,YAAYa,SAASF,WAAWC,aAAaZ,YAAYa,QAAQF,YAAYG,cAClF,IAGMb,UAATQ,SAAmBG,YAAYE,aAA+BF,YAAYE,aAAaH,UAA5CE;AACpD;;OAEM,SAAUE,iBACdC,WACAC,KACAX,QACAY,UACAP;IAEA,MAAMF,SAASD,qBAAqBF;IAIpC,IAFAP,OAAOiB,WAAW,GAAGP,SAAS,IAA8BE,WAAU,KAEjEM,KACH,QAAQ;IAKV,IAFAE,yBAAA,IAAAH,WAAeC,MAEXR,QACF,KAAK,IAAIW,IAAI,GAAGA,IAAIT,UAAUS,KAC5BD,yBAAA,IAAAH,YAAW,IAADI,GAAsCC,wBAAA,IAAAL,aAAUI,IAAI,MAAKF;IAGvE,OAAO;AACT;;OAEM,SAAUI,YACdN,WACAV,QACAY,UACAP;IAEA,MACMY,UADSf,qBAAqBF,UACXY,WAAWP,WAAWO;IAE/C,IAAIK,UAAU,GACZ,OAAOA;IAGT,MAAMN,MAAMd,SAASoB,UAEfC,MAAMT,iBAAiBC,WAAWC,KAAKX,QAAQY,UAAUP;IAE/D,OAAIa,MAAM,KACRtB,OAAOe,MACAO,OAGF;AACT;;OAEM,SAAUC,iBACdT,WACAU,QACApB,QACAM,WACAD;IAEA,MAAMF,SAASD,qBAAqBF,SAC9BqB,SAASlB,SAASE,WAAW,GAC7BiB,aAAavB,kBAAkBC,WAAWG,SAAS,IAAIE,WACvDkB,WAAWjB,YAAYgB,YACvBE,WAAkB,MAANxB,UAAoD,MAANA,SAC5D,MACA;IAEJoB,UAAUE;IAEV,KAAK,IAAIR,IAAI,GAAGA,IAAIO,QAAQP,KAC1BrB,OAAOsB,wBAAA,IAAAL,YAAW,IAADI,KAAKM,QAAQI,UAAUD;AAE5C","ignoreList":[]}

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

@@ -0,0 +1,64 @@
+import { AVCodecID, AVMediaType, AVPacketSideDataType } from "../codec";
+import AVPacket from "../struct/avpacket";
+import { Rational } from "../struct/rational";
+import { AVChromaLocation, AVColorPrimaries, AVColorRange, AVColorSpace, AVColorTransferCharacteristic, AVFieldOrder, AVPixelFormat } from "../pixfmt";
+import { AVChannelOrder, AVSampleFormat } from "../audiosamplefmt";
+import AVCodecParameters from "../struct/avcodecparameters";
+export interface AVPacketSerialize {
+    pts: int64;
+    dts: int64;
+    data: Uint8Array;
+    streamIndex: int32;
+    flags: int32;
+    sideData: {
+        type: AVPacketSideDataType;
+        data: Uint8Array;
+    }[];
+    duration: int64;
+    pos: int64;
+    timeBase: Rational;
+    bitFormat: int32;
+}
+export interface AVCodecParametersSerialize {
+    codecType: AVMediaType;
+    codecId: AVCodecID;
+    codecTag: uint32;
+    extradata: Uint8Array;
+    codedSideData: {
+        type: AVPacketSideDataType;
+        data: Uint8Array;
+    }[];
+    format: AVPixelFormat | AVSampleFormat;
+    bitrate: int64;
+    bitsPerCodedSample: int32;
+    bitsPerRawSample: int32;
+    profile: int32;
+    level: int32;
+    width: int32;
+    height: int32;
+    sampleAspectRatio: Rational;
+    framerate: Rational;
+    fieldOrder: AVFieldOrder;
+    colorRange: AVColorRange;
+    colorPrimaries: AVColorPrimaries;
+    colorTrc: AVColorTransferCharacteristic;
+    colorSpace: AVColorSpace;
+    chromaLocation: AVChromaLocation;
+    videoDelay: int32;
+    chLayout: {
+        order: AVChannelOrder;
+        nbChannels: int32;
+        u: uint64;
+    };
+    sampleRate: int32;
+    blockAlign: int32;
+    frameSize: int32;
+    initialPadding: int32;
+    trailingPadding: int32;
+    seekPreroll: int32;
+    bitFormat: int32;
+}
+export declare function serializeAVPacket(avpacket: pointer<AVPacket>): AVPacketSerialize;
+export declare function unserializeAVPacket(serialize: AVPacketSerialize, avpacket?: pointer<AVPacket>): pointer<AVPacket>;
+export declare function serializeAVCodecParameters(codecpar: pointer<AVCodecParameters>): AVCodecParametersSerialize;
+export declare function unserializeAVCodecParameters(serialize: AVCodecParametersSerialize, codecpar?: pointer<AVCodecParameters>): pointer<AVCodecParameters>;

package/dist/esm/util/serialize.js

@@ -0,0 +1,136 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__17 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { mapUint8Array, memcpyFromUint8Array, memset } from "@libmedia/cheap/std/memory";
+
+import { addAVPacketData, addAVPacketSideData, addSideData, createAVPacket, freeAVPacketSideData, getAVPacketData } from "./avpacket";
+
+import { avFree, avMalloc } from "./mem";
+
+import AVCodecParameters from "../struct/avcodecparameters";
+
+export function serializeAVPacket(avpacket) {
+    const serialize = {
+        pts: cheap__CTypeEnumRead__0[17](avpacket + 8),
+        dts: cheap__CTypeEnumRead__0[17](avpacket + 16),
+        data: getAVPacketData(avpacket).slice(),
+        streamIndex: cheap__CTypeEnumRead__0[15](avpacket + 32),
+        flags: cheap__CTypeEnumRead__0[15](avpacket + 36),
+        sideData: [],
+        duration: cheap__CTypeEnumRead__0[17](avpacket + 48),
+        pos: cheap__CTypeEnumRead__0[17](avpacket + 56),
+        timeBase: {
+            den: cheap__CTypeEnumRead__0[15](avpacket + 76),
+            num: cheap__CTypeEnumRead__0[15](avpacket + 72)
+        },
+        bitFormat: cheap__CTypeEnumRead__0[15](avpacket + 80)
+    };
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](avpacket + 44); i++) {
+        const ele = {
+            type: cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i + 8),
+            data: mapUint8Array(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i), cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](avpacket + 40) + 12 * i + 4)).slice()
+        };
+        serialize.sideData.push(ele);
+    }
+    return serialize;
+}
+
+export function unserializeAVPacket(serialize, avpacket = 0) {
+    avpacket || (avpacket = createAVPacket()), cheap__CTypeEnumWrite__17[17](avpacket + 8, serialize.pts), 
+    cheap__CTypeEnumWrite__17[17](avpacket + 16, serialize.dts);
+    const data = avMalloc(serialize.data.length);
+    if (memcpyFromUint8Array(data, serialize.data.length, serialize.data), addAVPacketData(avpacket, data, serialize.data.length), 
+    cheap__CTypeEnumWrite__17[15](avpacket + 32, serialize.streamIndex), cheap__CTypeEnumWrite__17[15](avpacket + 36, serialize.flags), 
+    cheap__CTypeEnumWrite__17[17](avpacket + 48, serialize.duration), cheap__CTypeEnumWrite__17[17](avpacket + 56, serialize.pos), 
+    cheap__CTypeEnumWrite__17[15](avpacket + 76, serialize.timeBase.den), cheap__CTypeEnumWrite__17[15](avpacket + 72, serialize.timeBase.num), 
+    cheap__CTypeEnumWrite__17[15](avpacket + 80, serialize.bitFormat), serialize.sideData.length) for (let i = 0; i < serialize.sideData.length; i++) {
+        const data = avMalloc(serialize.sideData[i].data.length);
+        memcpyFromUint8Array(data, serialize.sideData[i].data.length, serialize.sideData[i].data), 
+        addAVPacketSideData(avpacket, serialize.sideData[i].type, data, serialize.sideData[i].data.length);
+    } else freeAVPacketSideData(avpacket + 40, avpacket + 44);
+    return avpacket;
+}
+
+export function serializeAVCodecParameters(codecpar) {
+    const serialize = {
+        codecType: cheap__CTypeEnumRead__0[15](codecpar),
+        codecId: cheap__CTypeEnumRead__0[15](codecpar + 4),
+        codecTag: cheap__CTypeEnumRead__0[8](codecpar + 8),
+        extradata: null,
+        codedSideData: [],
+        format: cheap__CTypeEnumRead__0[15](codecpar + 28),
+        bitrate: cheap__CTypeEnumRead__0[17](codecpar + 32),
+        bitsPerCodedSample: cheap__CTypeEnumRead__0[15](codecpar + 40),
+        bitsPerRawSample: cheap__CTypeEnumRead__0[15](codecpar + 44),
+        profile: cheap__CTypeEnumRead__0[15](codecpar + 48),
+        level: cheap__CTypeEnumRead__0[15](codecpar + 52),
+        width: cheap__CTypeEnumRead__0[15](codecpar + 56),
+        height: cheap__CTypeEnumRead__0[15](codecpar + 60),
+        sampleAspectRatio: {
+            den: cheap__CTypeEnumRead__0[15](codecpar + 68),
+            num: cheap__CTypeEnumRead__0[15](codecpar + 64)
+        },
+        framerate: {
+            den: cheap__CTypeEnumRead__0[15](codecpar + 76),
+            num: cheap__CTypeEnumRead__0[15](codecpar + 72)
+        },
+        fieldOrder: cheap__CTypeEnumRead__0[15](codecpar + 80),
+        colorRange: cheap__CTypeEnumRead__0[15](codecpar + 84),
+        colorPrimaries: cheap__CTypeEnumRead__0[15](codecpar + 88),
+        colorTrc: cheap__CTypeEnumRead__0[15](codecpar + 92),
+        colorSpace: cheap__CTypeEnumRead__0[15](codecpar + 96),
+        chromaLocation: cheap__CTypeEnumRead__0[15](codecpar + 100),
+        videoDelay: cheap__CTypeEnumRead__0[15](codecpar + 104),
+        chLayout: {
+            order: cheap__CTypeEnumRead__0[15](codecpar + 112),
+            nbChannels: cheap__CTypeEnumRead__0[15](codecpar + 116),
+            u: cheap__CTypeEnumRead__0[10](codecpar + 120)
+        },
+        sampleRate: cheap__CTypeEnumRead__0[15](codecpar + 136),
+        blockAlign: cheap__CTypeEnumRead__0[15](codecpar + 140),
+        frameSize: cheap__CTypeEnumRead__0[15](codecpar + 144),
+        initialPadding: cheap__CTypeEnumRead__0[15](codecpar + 148),
+        trailingPadding: cheap__CTypeEnumRead__0[15](codecpar + 152),
+        seekPreroll: cheap__CTypeEnumRead__0[15](codecpar + 156),
+        bitFormat: cheap__CTypeEnumRead__0[15](codecpar + 160)
+    };
+    cheap__CTypeEnumRead__0[15](codecpar + 16) && (serialize.extradata = mapUint8Array(cheap__CTypeEnumRead__0[20](codecpar + 12), cheap__CTypeEnumRead__0[15](codecpar + 16)).slice());
+    for (let i = 0; i < cheap__CTypeEnumRead__0[15](codecpar + 24); i++) {
+        const ele = {
+            type: cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](codecpar + 20) + 12 * i + 8),
+            data: mapUint8Array(cheap__CTypeEnumRead__0[20](cheap__CTypeEnumRead__0[20](codecpar + 20) + 12 * i), cheap__CTypeEnumRead__0[15](cheap__CTypeEnumRead__0[20](codecpar + 20) + 12 * i + 4)).slice()
+        };
+        serialize.codedSideData.push(ele);
+    }
+    return serialize;
+}
+
+export function unserializeAVCodecParameters(serialize, codecpar = 0) {
+    if (codecpar || (codecpar = avMalloc(168), memset(codecpar, 0, 168)), cheap__CTypeEnumWrite__17[15](codecpar, serialize.codecType), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 4, serialize.codecId), cheap__CTypeEnumWrite__17[8](codecpar + 8, serialize.codecTag), 
+    serialize.extradata && (cheap__CTypeEnumRead__0[20](codecpar + 12) && avFree(cheap__CTypeEnumRead__0[20](codecpar + 12)), 
+    cheap__CTypeEnumWrite__17[20](codecpar + 12, avMalloc(serialize.extradata.length)), 
+    memcpyFromUint8Array(cheap__CTypeEnumRead__0[20](codecpar + 12), serialize.extradata.length, serialize.extradata), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 16, serialize.extradata.length)), serialize.codedSideData.length) for (let i = 0; i < serialize.codedSideData.length; i++) {
+        const data = avMalloc(serialize.codedSideData[i].data.length);
+        memcpyFromUint8Array(data, serialize.codedSideData[i].data.length, serialize.codedSideData[i].data), 
+        addSideData(codecpar + 20, codecpar + 24, serialize.codedSideData[i].type, data, serialize.codedSideData[i].data.length);
+    } else freeAVPacketSideData(codecpar + 20, codecpar + 24);
+    return cheap__CTypeEnumWrite__17[15](codecpar + 28, serialize.format), cheap__CTypeEnumWrite__17[17](codecpar + 32, serialize.bitrate), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 40, serialize.bitsPerCodedSample), cheap__CTypeEnumWrite__17[15](codecpar + 44, serialize.bitsPerRawSample), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 48, serialize.profile), cheap__CTypeEnumWrite__17[15](codecpar + 52, serialize.level), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 56, serialize.width), cheap__CTypeEnumWrite__17[15](codecpar + 60, serialize.height), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 68, serialize.sampleAspectRatio.den), cheap__CTypeEnumWrite__17[15](codecpar + 64, serialize.sampleAspectRatio.num), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 76, serialize.framerate.den), cheap__CTypeEnumWrite__17[15](codecpar + 72, serialize.framerate.num), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 80, serialize.fieldOrder), cheap__CTypeEnumWrite__17[15](codecpar + 84, serialize.colorRange), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 88, serialize.colorPrimaries), cheap__CTypeEnumWrite__17[15](codecpar + 92, serialize.colorTrc), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 96, serialize.colorSpace), cheap__CTypeEnumWrite__17[15](codecpar + 100, serialize.chromaLocation), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 104, serialize.videoDelay), cheap__CTypeEnumWrite__17[15](codecpar + 112, serialize.chLayout.order), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 116, serialize.chLayout.nbChannels), cheap__CTypeEnumWrite__17[10](codecpar + 120, serialize.chLayout.u), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 136, serialize.sampleRate), cheap__CTypeEnumWrite__17[15](codecpar + 140, serialize.blockAlign), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 144, serialize.frameSize), cheap__CTypeEnumWrite__17[15](codecpar + 148, serialize.initialPadding), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 152, serialize.trailingPadding), cheap__CTypeEnumWrite__17[15](codecpar + 156, serialize.seekPreroll), 
+    cheap__CTypeEnumWrite__17[15](codecpar + 160, serialize.bitFormat), codecpar;
+}
+//# sourceMappingURL=serialize.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["mapUint8Array","memcpyFromUint8Array","memset","addAVPacketData","addAVPacketSideData","addSideData","createAVPacket","freeAVPacketSideData","getAVPacketData","avFree","avMalloc","AVCodecParameters","serializeAVPacket","avpacket","serialize","pts","cheap__CTypeEnumRead__0","dts","data","slice","streamIndex","flags","sideData","duration","pos","timeBase","den","num","bitFormat","i","ele","type","push","unserializeAVPacket","cheap__CTypeEnumWrite__17","length","serializeAVCodecParameters","codecpar","codecType","codecId","codecTag","extradata","codedSideData","format","bitrate","bitsPerCodedSample","bitsPerRawSample","profile","level","width","height","sampleAspectRatio","framerate","fieldOrder","colorRange","colorPrimaries","colorTrc","colorSpace","chromaLocation","videoDelay","chLayout","order","nbChannels","u","sampleRate","blockAlign","frameSize","initialPadding","trailingPadding","seekPreroll","unserializeAVCodecParameters"],"sources":["../../../util/serialize.ts"],"mappings":";;;;SA4BSA,eAAeC,sBAAsBC,cAAQ;;SAC7CC,iBAAiBC,qBAAqBC,aAAaC,gBAAgBC,sBAAsBC,uBAAiB;;SAC1GC,QAAQC,gBAAU;;OAGpBC,uBAAiB;;OA0DlB,SAAUC,kBAAkBC;IAChC,MAAMC,YAA+B;QACnCC,KAAGC,wBAAA,IAAEH,WAAQ;QACbI,KAAGD,wBAAA,IAAEH,WAAQ;QACbK,MAAMV,gBAAgBK,UAAUM;QAChCC,aAAWJ,wBAAA,IAAEH,WAAQ;QACrBQ,OAAKL,wBAAA,IAAEH,WAAQ;QACfS,UAAU;QACVC,UAAQP,wBAAA,IAAEH,WAAQ;QAClBW,KAAGR,wBAAA,IAAEH,WAAQ;QACbY,UAAU;YACRC,KAAGV,wBAAA,IAAEH,WAAQ;YACbc,KAAGX,wBAAA,IAAEH,WAAQ;;QAEfe,WAASZ,wBAAA,IAAEH,WAAQ;;IAGrB,KAAK,IAAIgB,IAAI,GAAGA,IAACb,wBAAA,IAAGH,WAAQ,KAAgBgB,KAAK;QAC/C,MAAMC,MAAM;YACVC,MAAIf,wBAAA,IAAAA,wBAAA,IAAEH,WAAQ,MAAW,KAADgB,IAAC;YACzBX,MAAMlB,cAAagB,wBAAA,IAAAA,wBAAA,IAACH,WAAQ,MAAW,KAADgB,IAACb,wBAAA,IAAAA,wBAAA,IAAQH,WAAQ,MAAW,KAADgB,IAAC,IAAQV;;QAE5EL,UAAUQ,SAASU,KAAKF;AAC1B;IACA,OAAOhB;AACT;;OAEM,SAAUmB,oBAAoBnB,WAA8BD,WAAA;IAC3DA,aACHA,WAAWP,mBAGb4B,0BAAA,IAAArB,WAAQ,GAAOC,UAAUC;IACzBmB,0BAAA,IAAArB,WAAQ,IAAOC,UAAUG;IAEzB,MAAMC,OAAOR,SAASI,UAAUI,KAAKiB;IAYrC,IAXAlC,qBAAqBiB,MAAMJ,UAAUI,KAAKiB,QAAQrB,UAAUI,OAC5Df,gBAAgBU,UAAUK,MAAMJ,UAAUI,KAAKiB;IAE/CD,0BAAA,IAAArB,WAAQ,IAAeC,UAAUM,cACjCc,0BAAA,IAAArB,WAAQ,IAASC,UAAUO;IAC3Ba,0BAAA,IAAArB,WAAQ,IAAYC,UAAUS,WAC9BW,0BAAA,IAAArB,WAAQ,IAAOC,UAAUU;IACzBU,0BAAA,IAAArB,WAAQ,IAAgBC,UAAUW,SAASC,MAC3CQ,0BAAA,IAAArB,WAAQ,IAAgBC,UAAUW,SAASE;IAC3CO,0BAAA,IAAArB,WAAQ,IAAaC,UAAUc,YAE3Bd,UAAUQ,SAASa,QACrB,KAAK,IAAIN,IAAI,GAAGA,IAAIf,UAAUQ,SAASa,QAAQN,KAAK;QAClD,MAAMX,OAAOR,SAASI,UAAUQ,SAASO,GAAGX,KAAKiB;QACjDlC,qBAAqBiB,MAAMJ,UAAUQ,SAASO,GAAGX,KAAKiB,QAAQrB,UAAUQ,SAASO,GAAGX;QACpFd,oBAAoBS,UAAUC,UAAUQ,SAASO,GAAGE,MAAMb,MAAMJ,UAAUQ,SAASO,GAAGX,KAAKiB;AAC7F,WAGA5B,qBAA+BM,WAAQ,IAAsBA,WAAQ;IAGvE,OAAOA;AACT;;OAEM,SAAUuB,2BAA2BC;IACzC,MAAMvB,YAAwC;QAC5CwB,WAAStB,wBAAA,IAAEqB;QACXE,SAAOvB,wBAAA,IAAEqB,WAAQ;QACjBG,UAAQxB,wBAAA,GAAEqB,WAAQ;QAClBI,WAAW;QACXC,eAAe;QACfC,QAAM3B,wBAAA,IAAEqB,WAAQ;QAChBO,SAAO5B,wBAAA,IAAEqB,WAAQ;QACjBQ,oBAAkB7B,wBAAA,IAAEqB,WAAQ;QAC5BS,kBAAgB9B,wBAAA,IAAEqB,WAAQ;QAC1BU,SAAO/B,wBAAA,IAAEqB,WAAQ;QACjBW,OAAKhC,wBAAA,IAAEqB,WAAQ;QACfY,OAAKjC,wBAAA,IAAEqB,WAAQ;QACfa,QAAMlC,wBAAA,IAAEqB,WAAQ;QAChBc,mBAAmB;YACjBzB,KAAGV,wBAAA,IAAEqB,WAAQ;YACbV,KAAGX,wBAAA,IAAEqB,WAAQ;;QAEfe,WAAW;YACT1B,KAAGV,wBAAA,IAAEqB,WAAQ;YACbV,KAAGX,wBAAA,IAAEqB,WAAQ;;QAEfgB,YAAUrC,wBAAA,IAAEqB,WAAQ;QACpBiB,YAAUtC,wBAAA,IAAEqB,WAAQ;QACpBkB,gBAAcvC,wBAAA,IAAEqB,WAAQ;QACxBmB,UAAQxC,wBAAA,IAAEqB,WAAQ;QAClBoB,YAAUzC,wBAAA,IAAEqB,WAAQ;QACpBqB,gBAAc1C,wBAAA,IAAEqB,WAAQ;QACxBsB,YAAU3C,wBAAA,IAAEqB,WAAQ;QACpBuB,UAAU;YACRC,OAAK7C,wBAAA,IAAEqB,WAAQ;YACfyB,YAAU9C,wBAAA,IAAEqB,WAAQ;YACpB0B,GAAC/C,wBAAA,IAAEqB,WAAQ;;QAEb2B,YAAUhD,wBAAA,IAAEqB,WAAQ;QACpB4B,YAAUjD,wBAAA,IAAEqB,WAAQ;QACpB6B,WAASlD,wBAAA,IAAEqB,WAAQ;QACnB8B,gBAAcnD,wBAAA,IAAEqB,WAAQ;QACxB+B,iBAAepD,wBAAA,IAAEqB,WAAQ;QACzBgC,aAAWrD,wBAAA,IAAEqB,WAAQ;QACrBT,WAASZ,wBAAA,IAAEqB,WAAQ;;IAGrBrB,wBAAA,IAAIqB,WAAQ,QACVvB,UAAU2B,YAAYzC,cAAagB,wBAAA,IAACqB,WAAQ,KAAArB,wBAAA,IAAYqB,WAAQ,KAAgBlB;IAGlF,KAAK,IAAIU,IAAI,GAAGA,IAACb,wBAAA,IAAGqB,WAAQ,KAAkBR,KAAK;QACjD,MAAMC,MAAM;YACVC,MAAIf,wBAAA,IAAAA,wBAAA,IAAEqB,WAAQ,MAAgB,KAADR,IAAC;YAC9BX,MAAMlB,cAAagB,wBAAA,IAAAA,wBAAA,IAACqB,WAAQ,MAAgB,KAADR,IAACb,wBAAA,IAAAA,wBAAA,IAAQqB,WAAQ,MAAgB,KAADR,IAAC,IAAQV;;QAEtFL,UAAU4B,cAAcV,KAAKF;AAC/B;IAEA,OAAOhB;AACT;;OAEM,SAAUwD,6BAA6BxD,WAAuCuB,WAAA;IAkBlF,IAjBKA,aACHA,WAAW3B,SAAQ,MACnBR,OAAOmC,UAAU,GAAC,OAGpBH,0BAAA,IAAAG,UAAqBvB,UAAUwB;IAC/BJ,0BAAA,IAAAG,WAAQ,GAAWvB,UAAUyB,UAC7BL,0BAAA,GAAAG,WAAQ,GAAYvB,UAAU0B;IAE1B1B,UAAU2B,cACZzB,wBAAA,IAAIqB,WAAQ,OACV5B,OAAMO,wBAAA,IAACqB,WAAQ;IAEjBH,0BAAA,IAAAG,WAAQ,IAAa3B,SAASI,UAAU2B,UAAUN;IAClDlC,qBAAoBe,wBAAA,IAACqB,WAAQ,KAAYvB,UAAU2B,UAAUN,QAAQrB,UAAU2B;IAC/EP,0BAAA,IAAAG,WAAQ,IAAiBvB,UAAU2B,UAAUN,UAE3CrB,UAAU4B,cAAcP,QAC1B,KAAK,IAAIN,IAAI,GAAGA,IAAIf,UAAU4B,cAAcP,QAAQN,KAAK;QACvD,MAAMX,OAAOR,SAASI,UAAU4B,cAAcb,GAAGX,KAAKiB;QACtDlC,qBAAqBiB,MAAMJ,UAAU4B,cAAcb,GAAGX,KAAKiB,QAAQrB,UAAU4B,cAAcb,GAAGX;QAC9Fb,YAAsBgC,WAAQ,IAA2BA,WAAQ,IAAmBvB,UAAU4B,cAAcb,GAAGE,MAAMb,MAAMJ,UAAU4B,cAAcb,GAAGX,KAAKiB;AAC7J,WAGA5B,qBAA+B8B,WAAQ,IAA2BA,WAAQ;IAgC5E,OA9BAH,0BAAA,IAAAG,WAAQ,IAAUvB,UAAU6B,SAC5BT,0BAAA,IAAAG,WAAQ,IAAWvB,UAAU8B;IAC7BV,0BAAA,IAAAG,WAAQ,IAAsBvB,UAAU+B,qBACxCX,0BAAA,IAAAG,WAAQ,IAAoBvB,UAAUgC;IACtCZ,0BAAA,IAAAG,WAAQ,IAAWvB,UAAUiC,UAC7Bb,0BAAA,IAAAG,WAAQ,IAASvB,UAAUkC;IAC3Bd,0BAAA,IAAAG,WAAQ,IAASvB,UAAUmC,QAC3Bf,0BAAA,IAAAG,WAAQ,IAAUvB,UAAUoC;IAC5BhB,0BAAA,IAAAG,WAAQ,IAAyBvB,UAAUqC,kBAAkBzB,MAC7DQ,0BAAA,IAAAG,WAAQ,IAAyBvB,UAAUqC,kBAAkBxB;IAC7DO,0BAAA,IAAAG,WAAQ,IAAiBvB,UAAUsC,UAAU1B,MAC7CQ,0BAAA,IAAAG,WAAQ,IAAiBvB,UAAUsC,UAAUzB;IAC7CO,0BAAA,IAAAG,WAAQ,IAAcvB,UAAUuC,aAChCnB,0BAAA,IAAAG,WAAQ,IAAcvB,UAAUwC;IAChCpB,0BAAA,IAAAG,WAAQ,IAAkBvB,UAAUyC,iBACpCrB,0BAAA,IAAAG,WAAQ,IAAYvB,UAAU0C;IAC9BtB,0BAAA,IAAAG,WAAQ,IAAcvB,UAAU2C,aAChCvB,0BAAA,IAAAG,WAAQ,KAAkBvB,UAAU4C;IACpCxB,0BAAA,IAAAG,WAAQ,KAAcvB,UAAU6C,aAChCzB,0BAAA,IAAAG,WAAQ,KAAkBvB,UAAU8C,SAASC;IAC7C3B,0BAAA,IAAAG,WAAQ,KAAuBvB,UAAU8C,SAASE,aAClD5B,0BAAA,IAAAG,WAAQ,KAAmBvB,UAAU8C,SAASG;IAC9C7B,0BAAA,IAAAG,WAAQ,KAAcvB,UAAUkD,aAChC9B,0BAAA,IAAAG,WAAQ,KAAcvB,UAAUmD;IAChC/B,0BAAA,IAAAG,WAAQ,KAAavB,UAAUoD,YAC/BhC,0BAAA,IAAAG,WAAQ,KAAkBvB,UAAUqD;IACpCjC,0BAAA,IAAAG,WAAQ,KAAmBvB,UAAUsD,kBACrClC,0BAAA,IAAAG,WAAQ,KAAevB,UAAUuD;IACjCnC,0BAAA,IAAAG,WAAQ,KAAavB,UAAUc,YAExBS;AACT","ignoreList":[]}