@libmedia/avutil 0.11.0 → 1.0.0

package/src/util/serialize.ts

@@ -0,0 +1,268 @@
+/*
+ * libmedia serialize struct
+ *
+ * 版权所有 (C) 2024 赵高兴
+ * Copyright (C) 2024 Gaoxing Zhao
+ *
+ * 此文件是 libmedia 的一部分
+ * This file is part of libmedia.
+ * 
+ * libmedia 是自由软件；您可以根据 GNU Lesser General Public License（GNU LGPL）3.1
+ * 或任何其更新的版本条款重新分发或修改它
+ * libmedia is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3.1 of the License, or (at your option) any later version.
+ * 
+ * libmedia 希望能够为您提供帮助，但不提供任何明示或暗示的担保，包括但不限于适销性或特定用途的保证
+ * 您应自行承担使用 libmedia 的风险，并且需要遵守 GNU Lesser General Public License 中的条款和条件。
+ * libmedia is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ */
+
+import type { AVCodecID, AVMediaType, AVPacketSideDataType } from '../codec'
+import type AVPacket from '../struct/avpacket'
+import type { AVRational } from '../struct/rational'
+import { mapUint8Array, memcpyFromUint8Array, memset } from '@libmedia/cheap'
+import { addAVPacketData, addAVPacketSideData, addSideData, createAVPacket, freeAVPacketSideData, getAVPacketData } from './avpacket'
+import { avFree, avMalloc } from './mem'
+import type { AVChromaLocation, AVColorPrimaries, AVColorRange, AVColorSpace, AVColorTransferCharacteristic, AVFieldOrder, AVPixelFormat } from '../pixfmt'
+import type { 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: AVRational
+}
+
+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: AVRational
+  framerate: AVRational
+  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
+  flags: int32
+}
+
+export function serializeAVPacket(avpacket: pointer<AVPacket>) {
+  const serialize: AVPacketSerialize = {
+    pts: avpacket.pts,
+    dts: avpacket.dts,
+    data: getAVPacketData(avpacket).slice(),
+    streamIndex: avpacket.streamIndex,
+    flags: avpacket.flags,
+    sideData: [],
+    duration: avpacket.duration,
+    pos: avpacket.pos,
+    timeBase: {
+      den: avpacket.timeBase.den,
+      num: avpacket.timeBase.num
+    }
+  }
+
+  for (let i = 0; i < avpacket.sideDataElems; i++) {
+    const ele = {
+      type: avpacket.sideData[i].type,
+      data: mapUint8Array(avpacket.sideData[i].data, avpacket.sideData[i].size).slice()
+    }
+    serialize.sideData.push(ele)
+  }
+  return serialize
+}
+
+export function unserializeAVPacket(serialize: AVPacketSerialize, avpacket: pointer<AVPacket> = nullptr) {
+  if (!avpacket) {
+    avpacket = createAVPacket()
+  }
+
+  avpacket.pts = serialize.pts
+  avpacket.dts = serialize.dts
+
+  const data: pointer<uint8> = avMalloc(serialize.data.length)
+  memcpyFromUint8Array(data, serialize.data.length, serialize.data)
+  addAVPacketData(avpacket, data, serialize.data.length)
+
+  avpacket.streamIndex = serialize.streamIndex
+  avpacket.flags = serialize.flags
+  avpacket.duration = serialize.duration
+  avpacket.pos = serialize.pos
+  avpacket.timeBase.den = serialize.timeBase.den
+  avpacket.timeBase.num = serialize.timeBase.num
+
+  if (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(addressof(avpacket.sideData), addressof(avpacket.sideDataElems))
+  }
+
+  return avpacket
+}
+
+export function serializeAVCodecParameters(codecpar: pointer<AVCodecParameters>) {
+  const serialize: AVCodecParametersSerialize = {
+    codecType: codecpar.codecType,
+    codecId: codecpar.codecId,
+    codecTag: codecpar.codecTag,
+    extradata: null,
+    codedSideData: [],
+    format: codecpar.format,
+    bitrate: codecpar.bitrate,
+    bitsPerCodedSample: codecpar.bitsPerCodedSample,
+    bitsPerRawSample: codecpar.bitsPerRawSample,
+    profile: codecpar.profile,
+    level: codecpar.level,
+    width: codecpar.width,
+    height: codecpar.height,
+    sampleAspectRatio: {
+      den: codecpar.sampleAspectRatio.den,
+      num: codecpar.sampleAspectRatio.num
+    },
+    framerate: {
+      den: codecpar.framerate.den,
+      num: codecpar.framerate.num
+    },
+    fieldOrder: codecpar.fieldOrder,
+    colorRange: codecpar.colorRange,
+    colorPrimaries: codecpar.colorPrimaries,
+    colorTrc: codecpar.colorTrc,
+    colorSpace: codecpar.colorSpace,
+    chromaLocation: codecpar.chromaLocation,
+    videoDelay: codecpar.videoDelay,
+    chLayout: {
+      order: codecpar.chLayout.order,
+      nbChannels: codecpar.chLayout.nbChannels,
+      u: codecpar.chLayout.u.mask
+    },
+    sampleRate: codecpar.sampleRate,
+    blockAlign: codecpar.blockAlign,
+    frameSize: codecpar.frameSize,
+    initialPadding: codecpar.initialPadding,
+    trailingPadding: codecpar.trailingPadding,
+    seekPreroll: codecpar.seekPreroll,
+    flags: codecpar.flags
+  }
+
+  if (codecpar.extradataSize) {
+    serialize.extradata = mapUint8Array(codecpar.extradata, reinterpret_cast<size>(codecpar.extradataSize)).slice()
+  }
+
+  for (let i = 0; i < codecpar.nbCodedSideData; i++) {
+    const ele = {
+      type: codecpar.codedSideData[i].type,
+      data: mapUint8Array(codecpar.codedSideData[i].data, codecpar.codedSideData[i].size).slice()
+    }
+    serialize.codedSideData.push(ele)
+  }
+
+  return serialize
+}
+
+export function unserializeAVCodecParameters(serialize: AVCodecParametersSerialize, codecpar: pointer<AVCodecParameters> = nullptr) {
+  if (!codecpar) {
+    codecpar = reinterpret_cast<pointer<AVCodecParameters>>(avMalloc(sizeof(AVCodecParameters)))
+    memset(codecpar, 0, sizeof(AVCodecParameters))
+  }
+
+  codecpar.codecType = serialize.codecType
+  codecpar.codecId = serialize.codecId
+  codecpar.codecTag = serialize.codecTag
+
+  if (serialize.extradata) {
+    if (codecpar.extradata) {
+      avFree(codecpar.extradata)
+    }
+    codecpar.extradata = avMalloc(serialize.extradata.length)
+    memcpyFromUint8Array(codecpar.extradata, serialize.extradata.length, serialize.extradata)
+    codecpar.extradataSize = serialize.extradata.length
+  }
+  if (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(addressof(codecpar.codedSideData), addressof(codecpar.nbCodedSideData), serialize.codedSideData[i].type, data, serialize.codedSideData[i].data.length)
+    }
+  }
+  else {
+    freeAVPacketSideData(addressof(codecpar.codedSideData), addressof(codecpar.nbCodedSideData))
+  }
+  codecpar.format = serialize.format
+  codecpar.bitrate = serialize.bitrate
+  codecpar.bitsPerCodedSample = serialize.bitsPerCodedSample
+  codecpar.bitsPerRawSample = serialize.bitsPerRawSample
+  codecpar.profile = serialize.profile
+  codecpar.level = serialize.level
+  codecpar.width = serialize.width
+  codecpar.height = serialize.height
+  codecpar.sampleAspectRatio.den = serialize.sampleAspectRatio.den
+  codecpar.sampleAspectRatio.num = serialize.sampleAspectRatio.num
+  codecpar.framerate.den = serialize.framerate.den
+  codecpar.framerate.num = serialize.framerate.num
+  codecpar.fieldOrder = serialize.fieldOrder
+  codecpar.colorRange = serialize.colorRange
+  codecpar.colorPrimaries = serialize.colorPrimaries
+  codecpar.colorTrc = serialize.colorTrc
+  codecpar.colorSpace = serialize.colorSpace
+  codecpar.chromaLocation = serialize.chromaLocation
+  codecpar.videoDelay = serialize.videoDelay
+  codecpar.chLayout.order = serialize.chLayout.order
+  codecpar.chLayout.nbChannels = serialize.chLayout.nbChannels
+  codecpar.chLayout.u.mask = serialize.chLayout.u
+  codecpar.sampleRate = serialize.sampleRate
+  codecpar.blockAlign = serialize.blockAlign
+  codecpar.frameSize = serialize.frameSize
+  codecpar.initialPadding = serialize.initialPadding
+  codecpar.trailingPadding = serialize.trailingPadding
+  codecpar.seekPreroll = serialize.seekPreroll
+  codecpar.flags = serialize.flags
+
+  return codecpar
+}

package/dist/cjs/AVStream.d.ts

@@ -1,334 +0,0 @@
-import { Data } from "@libmedia/common/types/type";
-import AVCodecParameters from "./struct/avcodecparameters";
-import { AVPacketSideDataType } from "./codec";
-import { Rational } from "./struct/rational";
-export declare const enum AVStreamMetadataKey {
-    /**
-     * 表演者（歌手、乐队等）
-     */
-    ARTIST = "artist",
-    /**
-     * 自由文本评论
-     */
-    COMMENT = "comment",
-    /**
-     * 版权声明
-     */
-    COPYRIGHT = "copyright",
-    /**
-     * 发行年份（通常为 YYYY 格式）
-     */
-    DATE = "date",
-    /**
-     * 音乐流派
-     */
-    GENRE = "genre",
-    /**
-     * 语言
-     */
-    LANGUAGE = "language",
-    /**
-     * 语言描述
-     */
-    LANGUAGE_STRING = "languageString",
-    /**
-     * 歌曲或作品的标题
-     */
-    TITLE = "title",
-    /**
-     * 专辑名称
-     */
-    ALBUM = "album",
-    /**
-     * 曲目编号
-     */
-    TRACK = "track",
-    /**
-     * 用于编码音频文件的软件信息
-     */
-    ENCODER = "encoder",
-    /**
-     * 时间参数
-     */
-    TIME_CODE = "timecode",
-    /**
-     * 发行商
-     */
-    VENDOR = "vendor",
-    /**
-     * 发行商标识
-     */
-    VENDOR_ID = "vendorId",
-    /**
-     * 海报
-     */
-    POSTER = "poster",
-    /**
-     * 歌词
-     */
-    LYRICS = "lyrics",
-    /**
-     * 专辑的主要艺术家（与 ARTIST 区分开，适用于合集专辑）
-     */
-    ALBUM_ARTIST = "albumArtist",
-    /**
-     * 如果是多张 CD 的专辑，标识当前曲目所在的 CD
-     */
-    DISC = "disc",
-    /**
-     * 具体的演奏者或表演者
-     */
-    PERFORMER = "performer",
-    /**
-     * 发行者
-     */
-    PUBLISHER = "publisher",
-    /**
-     * 作曲者
-     */
-    COMPOSER = "composer",
-    /**
-     * 编曲者
-     */
-    COMPILATION = "compilation",
-    /**
-     * 创建时间
-     */
-    CREATION_TIME = "creationTime",
-    /**
-     * 最后更改时间
-     */
-    MODIFICATION_TIME = "modificationTime",
-    /**
-     * 专辑排序
-     */
-    ALBUM_SORT = "albumSort",
-    /**
-     * 表演者排序
-     */
-    ARTIST_SORT = "artistSort",
-    /**
-     * 标题排序
-     */
-    TITLE_SORT = "titleSort",
-    /**
-     * 分组
-     */
-    GROUPING = "grouping",
-    /**
-     * 额外的描述信息
-     */
-    DESCRIPTION = "description",
-    /**
-     * 许可信息
-     */
-    LICENSE = "license",
-    /**
-     * 国际标准录音代码
-     */
-    ISRC = "isrc",
-    /**
-     * 情绪标签，如 Happy、Sad
-     */
-    MOOD = "mood",
-    /**
-     * mp4 的 elst box 内容
-     */
-    ELST = "elst",
-    /**
-     * mp4 的旋转矩阵
-     */
-    MATRIX = "matrix",
-    /**
-     * 某些媒体的样式（如 webvtt）
-     */
-    STYLES = "styles",
-    /**
-     * 媒体的 mime
-     */
-    MIME = "mime",
-    /**
-     * mp4 的 handlerName
-     */
-    HANDLER_NAME = "handlerName",
-    /**
-     * DRM 系统支持信息
-     */
-    ENCRYPTION = "encryption"
-}
-export declare const enum AVDisposition {
-    NONE = 0,
-    DEFAULT = 1,
-    DUB = 2,
-    ORIGINAL = 4,
-    COMMENT = 8,
-    LYRICS = 16,
-    KARAOKE = 32,
-    /**
-     * Track should be used during playback by default.
-     * Useful for subtitle track that should be displayed
-     * even when user did not explicitly ask for subtitles.
-     */
-    FORCED = 64,
-    /**
-     * stream for hearing impaired audiences
-     */
-    HEARING_IMPAIRED = 128,
-    /**
-     * stream for visual impaired audiences
-     */
-    VISUAL_IMPAIRED = 256,
-    /**
-     * stream without voice
-     */
-    CLEAN_EFFECTS = 512,
-    /**
-     * The stream is stored in the file as an attached picture/"cover art" (e.g.
-     * APIC frame in ID3v2). The first (usually only) packet associated with it
-     * will be returned among the first few packets read from the file unless
-     * seeking takes place. It can also be accessed at any time in
-     * AVStream.attached_pic.
-     */
-    ATTACHED_PIC = 1024,
-    /**
-     * The stream is sparse, and contains thumbnail images, often corresponding
-     * to chapter markers. Only ever used with AV_DISPOSITION_ATTACHED_PIC.
-     */
-    TIMED_THUMBNAILS = 2048,
-    /**
-     * To specify text track kind (different from subtitles default).
-     */
-    CAPTIONS = 65536,
-    DESCRIPTIONS = 131072,
-    METADATA = 262144,
-    /**
-     * dependent audio stream (mix_type=0 in mpegts)
-     */
-    DEPENDENT = 524288,
-    /**
-     * still images in video stream (still_picture_flag=1 in mpegts
-     */
-    STILL_IMAGE = 1048576
-}
-/**
- * from FFmpeg
- *
- */
-export default class AVStream {
-    /**
-     * stream index in AVFormatContext
-     */
-    index: int32;
-    /**
-     * Format-specific stream ID.
-     * decoding: set by libavformat
-     * encoding: set by the user, replaced by libavformat if left unset
-     */
-    id: int32;
-    /**
-     * format private data
-     */
-    privData: Data;
-    /**
-     * demuxer or muxer's private data
-     */
-    privateData2: Data;
-    codecpar: AVCodecParameters;
-    /**
-     * An array of side data that applies to the whole stream (i.e. the
-     * container does not allow it to change between packets).
-     *
-     * There may be no overlap between the side data in this array and side data
-     * in the packets. I.e. a given side data is either exported by the muxer
-     * (demuxing) / set by the caller (muxing) in this array, then it never
-     * appears in the packets, or the side data is exported / sent through
-     * the packets (always in the first packet where the value becomes known or
-     * changes), then it does not appear in this array.
-     *
-     * - demuxing: Set by libavformat when the stream is created.
-     * - muxing: May be set by the caller before write_header().
-     *
-     */
-    sideData: Partial<Record<AVPacketSideDataType, Uint8Array>>;
-    /**
-     * number of frames in this stream if known or 0
-     */
-    nbFrames: int64;
-    metadata: Data;
-    /**
-     * Decoding: duration of the stream, in stream time base.
-     * If a source file does not specify a duration, but does specify
-     * a bitrate, this value will be estimated from bitrate and file size.
-     *
-     * Encoding: May be set by the caller before avformat_write_header() to
-     * provide a hint to the muxer about the estimated duration.
-     */
-    duration: int64;
-    /**
-     * Decoding: pts of the first frame of the stream in presentation order, in stream time base.
-     * Only set this if you are absolutely 100% sure that the value you set
-     * it to really is the pts of the first frame.
-     * This may be undefined (AV_NOPTS_VALUE).
-     * @note The ASF header does NOT contain a correct start_time the ASF
-     * demuxer must NOT set this.
-     */
-    startTime: int64;
-    /**
-     * 第一个 packet 的 dts
-     */
-    firstDTS: int64;
-    /**
-     * AV_DISPOSITION_* bit field
-     */
-    disposition: AVDisposition;
-    /**
-     *
-     * 封装时间基
-     *
-     * decoding: set by libavformat
-     * encoding: May be set by the caller before avformat_write_header() to
-     *           provide a hint to the muxer about the desired timebase. In
-     *           avformat_write_header(), the muxer will overwrite this field
-     *           with the timebase that will actually be used for the timestamps
-     *           written into the file (which may or may not be related to the
-     *           user-provided one, depending on the format).
-     */
-    timeBase: Rational;
-    /**
-     * 帧索引，可用于 seek
-     */
-    sampleIndexes: {
-        dts: int64;
-        pts: int64;
-        pos: int64;
-        size: int32;
-        duration: int64;
-        flags: int32;
-    }[];
-    /**
-     * pos 到 sample index 的映射
-     */
-    sampleIndexesPosMap: Map<int64, int32>;
-    destroy(): void;
-}
-export interface AVStreamInterface {
-    index: number;
-    id: number;
-    codecpar: pointer<AVCodecParameters>;
-    nbFrames: int64;
-    metadata: Data;
-    duration: int64;
-    startTime: int64;
-    disposition: int32;
-    timeBase: Rational;
-}
-export interface AVStreamMetadataEncryption {
-    schemeType: number;
-    schemeVersion: number;
-    cryptByteBlock?: number;
-    skipByteBlock?: number;
-    perSampleIVSize: number;
-    kid: Uint8Array;
-    constantIV?: Uint8Array;
-    pattern?: boolean;
-}

package/dist/cjs/AVStream.js

@@ -1,37 +0,0 @@
-"use strict";
-
-var __importDefault = this && this.__importDefault || function(mod) {
-    return mod && mod.__esModule ? mod : {
-        default: mod
-    };
-};
-
-Object.defineProperty(exports, "__esModule", {
-    value: !0
-});
-
-const cheap__identifier__0 = require("./struct/avcodecparameters"), cheap__identifier__1 = require("@libmedia/cheap/std/make"), cheap__identifier__2 = require("./struct/rational"), cheap__identifier__4 = require("@libmedia/cheap/std/unmake"), avcodecparameters_1 = __importDefault(require("./struct/avcodecparameters")), constant_1 = require("./constant");
-
-exports.default = class {
-    index=constant_1.NOPTS_VALUE;
-    id=constant_1.NOPTS_VALUE;
-    privData=null;
-    privateData2=null;
-    codecpar=cheap__identifier__1.default(new avcodecparameters_1.default, cheap__identifier__0.default);
-    sideData={};
-    nbFrames=BigInt(0);
-    metadata={};
-    duration=constant_1.NOPTS_VALUE_BIGINT;
-    startTime=constant_1.NOPTS_VALUE_BIGINT;
-    firstDTS=constant_1.NOPTS_VALUE_BIGINT;
-    disposition=0;
-    timeBase=cheap__identifier__1.default(cheap__identifier__2.Rational);
-    sampleIndexes=[];
-    sampleIndexesPosMap=new Map;
-    destroy() {
-        this.codecpar && (this.codecpar.destroy(), cheap__identifier__4.default(this.codecpar), 
-        this.codecpar = null), this.timeBase && (cheap__identifier__4.default(this.timeBase), 
-        this.timeBase = null), this.sampleIndexes.length = 0, this.sampleIndexesPosMap.clear();
-    }
-};
-//# sourceMappingURL=AVStream.js.map