@libmedia/avutil 0.2.0

package/dist/esm/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/esm/function/videoFrame2AVFrame.js

@@ -0,0 +1,111 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__1 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { createAVFrame, getVideoBuffer } from "../util/avframe";
+
+import { PixelFormatDescriptorsMap } from "../pixelFormatDescriptor";
+
+import { getHeapU8 } from "@libmedia/cheap/heap";
+
+export 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;
+    }
+}
+
+export function mapColorSpace(colorSpace) {
+    switch (colorSpace) {
+      case "bt709":
+      default:
+        return 1;
+
+      case "smpte170m":
+        return 6;
+
+      case "bt470bg":
+        return 5;
+
+      case "rgb":
+        return 0;
+    }
+}
+
+export function mapColorPrimaries(colorPrimaries) {
+    switch (colorPrimaries) {
+      case "bt709":
+      default:
+        return 1;
+
+      case "bt470bg":
+        return 5;
+
+      case "smpte170m":
+        return 6;
+    }
+}
+
+export function mapColorTrc(colorTrc) {
+    switch (colorTrc) {
+      case "bt709":
+      default:
+        return 1;
+
+      case "iec61966-2-1":
+        return 13;
+
+      case "smpte170m":
+        return 6;
+    }
+}
+
+export function videoFrame2AVFrame(videoFrame, avframe = 0) {
+    0 === avframe && (avframe = createAVFrame()), cheap__CTypeEnumWrite__1[15](avframe + 80, mapFormat(videoFrame.format)), 
+    cheap__CTypeEnumWrite__1[17](avframe + 104, BigInt(Math.floor(videoFrame.timestamp))), 
+    cheap__CTypeEnumWrite__1[15](avframe + 68, videoFrame.codedWidth), cheap__CTypeEnumWrite__1[15](avframe + 72, videoFrame.codedHeight), 
+    cheap__CTypeEnumWrite__1[17](avframe + 312, BigInt(Math.floor(videoFrame.duration))), 
+    cheap__CTypeEnumWrite__1[15](avframe + 220, mapColorSpace(videoFrame.colorSpace.matrix)), 
+    cheap__CTypeEnumWrite__1[15](avframe + 212, mapColorPrimaries(videoFrame.colorSpace.primaries)), 
+    cheap__CTypeEnumWrite__1[15](avframe + 216, mapColorTrc(videoFrame.colorSpace.transfer)), 
+    cheap__CTypeEnumWrite__1[15](avframe + 208, videoFrame.colorSpace.fullRange ? 2 : 1), 
+    videoFrame.visibleRect && (cheap__CTypeEnumWrite__1[15](avframe + 276, videoFrame.visibleRect.left), 
+    cheap__CTypeEnumWrite__1[15](avframe + 280, videoFrame.visibleRect.right), cheap__CTypeEnumWrite__1[15](avframe + 268, videoFrame.visibleRect.top), 
+    cheap__CTypeEnumWrite__1[15](avframe + 272, videoFrame.visibleRect.bottom)), getVideoBuffer(avframe);
+    const des = PixelFormatDescriptorsMap[cheap__CTypeEnumRead__0[15](avframe + 80)], layout = [];
+    for (let i = 0; i < des.nbComponents; i++) des.comp[i].plane >= i && layout.push({
+        offset: cheap__CTypeEnumRead__0[20](avframe + 4 * i),
+        stride: cheap__CTypeEnumRead__0[15](avframe + 32 + 4 * i)
+    });
+    return videoFrame.copyTo(getHeapU8(), {
+        layout: layout
+    }), avframe;
+}
+//# sourceMappingURL=videoFrame2AVFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAVFrame","getVideoBuffer","PixelFormatDescriptorsMap","getHeapU8","mapFormat","format","mapColorSpace","colorSpace","mapColorPrimaries","colorPrimaries","mapColorTrc","colorTrc","videoFrame2AVFrame","videoFrame","avframe","cheap__CTypeEnumWrite__1","BigInt","Math","floor","timestamp","codedWidth","codedHeight","duration","matrix","primaries","transfer","fullRange","visibleRect","left","right","top","bottom","des","cheap__CTypeEnumRead__0","layout","i","nbComponents","comp","plane","push","offset","stride","copyTo"],"sources":["../../../function/videoFrame2AVFrame.ts"],"mappings":";;;;SAwBSA,eAAeC,sBAAgB;;SAG/BC,iCAA2B;;SAC3BC,iBAAW;;OAEd,SAAUC,UAAUC;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;;OAEM,SAAUC,cAAcC;IAC5B,QAAQA;MACN,KAAK;MAQL;QACE;;MAPF,KAAK;QACH;;MACF,KAAK;QACH;;MACF,KAAK;QACH;;AAIN;;OAEM,SAAUC,kBAAkBC;IAChC,QAAQA;MACN,KAAK;MAML;QACE;;MALF,KAAK;QACH;;MACF,KAAK;QACH;;AAIN;;OAEM,SAAUC,YAAYC;IAC1B,QAAQA;MACN,KAAK;MAML;QACE;;MALF,KAAK;QACH;;MACF,KAAK;QACH;;AAIN;;OAEM,SAAUC,mBAAmBC,YAAwBC,UAAA;IAC9C,MAAPA,YACFA,UAAUd,kBAGZe,yBAAA,IAAAD,UAAO,IAAUV,UAAUS,WAAWR;IACtCU,yBAAA,IAAAD,UAAO,KAAAE,OAAAC,KAAAC,MAA0BL,WAAWM;IAC5CJ,yBAAA,IAAAD,UAAO,IAASD,WAAWO,aAC3BL,yBAAA,IAAAD,UAAO,IAAUD,WAAWQ;IAC5BN,yBAAA,IAAAD,UAAO,KAAAE,OAAAC,KAAAC,MAA+BL,WAAWS;IAEjDP,yBAAA,IAAAD,UAAO,KAAcR,cAAcO,WAAWN,WAAWgB;IACzDR,yBAAA,IAAAD,UAAO,KAAkBN,kBAAkBK,WAAWN,WAAWiB;IACjET,yBAAA,IAAAD,UAAO,KAAYJ,YAAYG,WAAWN,WAAWkB;IACrDV,yBAAA,IAAAD,UAAO,KAAcD,WAAWN,WAAWmB,YAAW,IAAgC;IAElFb,WAAWc,gBACbZ,yBAAA,IAAAD,UAAO,KAAYD,WAAWc,YAAYC;IAC1Cb,yBAAA,IAAAD,UAAO,KAAaD,WAAWc,YAAYE,QAC3Cd,yBAAA,IAAAD,UAAO,KAAWD,WAAWc,YAAYG;IACzCf,yBAAA,IAAAD,UAAO,KAAcD,WAAWc,YAAYI,UAG9C9B,eAAea;IAEf,MAAMkB,MAAM9B,0BAA0B+B,wBAAA,IAAAnB,UAAO,MACvCoB,SAAwB;IAC9B,KAAK,IAAIC,IAAI,GAAGA,IAAIH,IAAII,cAAcD,KAChCH,IAAIK,KAAKF,GAAGG,SAASH,KACvBD,OAAOK,KAAK;QACVC,QAAMP,wBAAA,IAAEnB,UAAO;QACf2B,QAAMR,wBAAA,IAAEnB,UAAO;;IASrB,OAJAD,WAAW6B,OAAOvC,aAAa;QAC7B+B;QAGKpB;AACT","ignoreList":[]}

package/dist/esm/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/esm/implement/AVFramePoolImpl.js

@@ -0,0 +1,32 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__2 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { AVFrameRef } from "../struct/avframe";
+
+import * as atomics from "@libmedia/cheap/thread/atomics";
+
+import * as mutex from "@libmedia/cheap/thread/mutex";
+
+import { avMallocz } from "../util/mem";
+
+import { getAVFrameDefault, unrefAVFrame } from "../util/avframe";
+
+export default class AVFramePoolImpl {
+    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 = avMallocz(328), getAVFrameDefault(avframe), cheap__CTypeEnumWrite__2[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) && (unrefAVFrame(avframe), 
+        atomics.store(avframe + 320, -1, 16, 2));
+    }
+}
+//# sourceMappingURL=AVFramePoolImpl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["AVFrameRef","atomics","mutex","avMallocz","getAVFrameDefault","unrefAVFrame","AVFramePoolImpl","list","constructor","this","alloc","avframe","find","compareExchange","cheap__CTypeEnumWrite__2","lock","push","unlock","release","load","sub","store"],"sources":["../../../implement/AVFramePoolImpl.ts"],"mappings":";;;;SAyBsBA,kBAAY;;YAGtBC,aAAO;;YACPC,WAAK;;SACRC,iBAAW;;SACXC,mBAAmBC,oBAAc;;eAE5B,MAAOC;IAEXC;IAEAL;IAER,WAAAM,CAAYD,MAAiCL;QAC3CO,KAAKF,OAAOA,MACZE,KAAKP,QAAQA;AACf;IAEO,KAAAQ;QACL,IAAIC,UAAUF,KAAKF,KAAKK,MAAMD,YAC4C,MAAjEV,QAAQY,gBAA0BF,UAAO,MAAa,GAAG,GAAC,SAClE;QAoBD,OAnBKA,YACHA,UAAUR,UAAS,MAEnBC,kBAAkBO,UAElBG,yBAAA,IAAAH,UAAO,KAAY;QAIjBT,MAAMa,KAAKN,KAAKP,QAGlBO,KAAKF,KAAKS,KAAKL,SAAO,KAGpBT,MAAMe,OAAOR,KAAKP;QAIfS;AACT;IACO,OAAAO,CAAQP;QACTV,QAAQkB,KAAeR,UAAO,eAAe,KAGG,MAAhDV,QAAQmB,IAAcT,UAAO,KAAY,GAAC,WAC5CN,aAAaM;QACbV,QAAQoB,MAAgBV,UAAO,MAAa,GAAC;AAEjD","ignoreList":[]}

package/dist/esm/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/esm/implement/AVPCMBufferPoolImpl.js

@@ -0,0 +1,28 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__2 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import { AVPCMBufferRef } from "../struct/avpcmbuffer";
+
+import * as atomics from "@libmedia/cheap/thread/atomics";
+
+import * as mutex from "@libmedia/cheap/thread/mutex";
+
+import { avMallocz } from "../util/mem";
+
+export default class AVPCMBufferPoolImpl {
+    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 = avMallocz(48), cheap__CTypeEnumWrite__2[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/esm/implement/AVPCMBufferPoolImpl.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AVPCMBufferRef","atomics","mutex","avMallocz","AVPCMBufferPoolImpl","list","constructor","this","alloc","buffer","find","compareExchange","cheap__CTypeEnumWrite__2","lock","push","unlock","release","load","sub","store"],"sources":["../../../implement/AVPCMBufferPoolImpl.ts"],"mappings":";;;;SAyB0BA,sBAAgB;;YAG9BC,aAAO;;YACPC,WAAK;;SACRC,iBAAW;;eAEN,MAAOC;IAEXC;IAEAH;IAER,WAAAI,CAAYD,MAAqCH;QAC/CK,KAAKF,OAAOA,MACZE,KAAKL,QAAQA;AACf;IAEO,KAAAM;QACL,IAAIC,SAASF,KAAKF,KAAKK,MAAMD,WAC4C,MAAhER,QAAQU,gBAA0BF,SAAM,KAAa,GAAG,GAAC,SACjE;QAkBD,OAjBKA,WACHA,SAASN,UAAS,KAElBS,yBAAA,IAAAH,SAAM,IAAY;QAIhBP,MAAMW,KAAKN,KAAKL,QAGlBK,KAAKF,KAAKS,KAAKL,QAAM,KAGnBP,MAAMa,OAAOR,KAAKL,SAIfO;AACT;IACO,OAAAO,CAAQP;QACTR,QAAQgB,KAAeR,SAAM,cAAe,KAGG,MAA/CR,QAAQiB,IAAcT,SAAM,IAAY,GAAC,UAC3CR,QAAQkB,MAAgBV,SAAM,KAAa,GAAC;AAEhD","ignoreList":[]}

package/dist/esm/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/esm/implement/AVPacketPoolImpl.js

@@ -0,0 +1,32 @@
+import { CTypeEnumRead as cheap__CTypeEnumRead__0 } from "@libmedia/cheap/ctypeEnumRead";
+
+import { CTypeEnumWrite as cheap__CTypeEnumWrite__2 } from "@libmedia/cheap/ctypeEnumWrite";
+
+import * as atomics from "@libmedia/cheap/thread/atomics";
+
+import * as mutex from "@libmedia/cheap/thread/mutex";
+
+import { avMallocz } from "../util/mem";
+
+import { AVPacketRef } from "../struct/avpacket";
+
+import { getAVPacketDefault, unrefAVPacket } from "../util/avpacket";
+
+export default class AVPacketPoolImpl {
+    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 = avMallocz(96), getAVPacketDefault(avpacket), cheap__CTypeEnumWrite__2[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) && (unrefAVPacket(avpacket), 
+        atomics.store(avpacket + 88, -1, 16, 2));
+    }
+}
+//# sourceMappingURL=AVPacketPoolImpl.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["atomics","mutex","avMallocz","AVPacketRef","getAVPacketDefault","unrefAVPacket","AVPacketPoolImpl","list","constructor","this","alloc","avpacket","find","compareExchange","cheap__CTypeEnumWrite__2","lock","push","unlock","release","load","sub","store"],"sources":["../../../implement/AVPacketPoolImpl.ts"],"mappings":";;;;YA2BYA,aAAO;;YACPC,WAAK;;SACRC,iBAAW;;SACGC,mBAAa;;SAC3BC,oBAAoBC,qBAAe;;eAE9B,MAAOC;IAEXC;IAEAN;IAER,WAAAO,CAAYD,MAAkCN;QAC5CQ,KAAKF,OAAOA,MACZE,KAAKR,QAAQA;AACf;IAEO,KAAAS;QACL,IAAIC,WAAWF,KAAKF,KAAKK,MAAMD,aAC4C,MAAlEX,QAAQa,gBAA0BF,WAAQ,KAAa,GAAG,GAAC,SACnE;QAmBD,OAlBKA,aACHA,WAAWT,UAAS,KACpBE,mBAAmBO,WAEnBG,yBAAA,IAAAH,WAAQ,IAAY;QAIlBV,MAAMc,KAAKN,KAAKR,QAGlBQ,KAAKF,KAAKS,KAAKL,UAAQ,KAGrBV,MAAMgB,OAAOR,KAAKR;QAIfU;AACT;IACO,OAAAO,CAAQP;QACTX,QAAQmB,KAAeR,WAAQ,cAAe,KAGG,MAAjDX,QAAQoB,IAAcT,WAAQ,IAAY,GAAC,WAC7CN,cAAcM;QACdX,QAAQqB,MAAgBV,WAAQ,KAAa,GAAC;AAElD","ignoreList":[]}

package/dist/esm/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>>;