@libmedia/avutil 0.12.0 → 1.0.1

package/src/util/pixel.ts

@@ -0,0 +1,381 @@
+/*
+ * libmedia video pixel util
+ *
+ * 版权所有 (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 { AVPixelFormatDescriptor } from '../pixelFormatDescriptor'
+import { getAVPixelFormatDescriptor, AVPixelFormatFlags } from '../pixelFormatDescriptor'
+import { AVChromaLocation, AVPixelFormat } from '../pixfmt'
+import * as errorType from '../error'
+import { INT32_MAX } from '../constant'
+import { avFree, avMalloc } from './mem'
+
+import { memset, stack } from '@libmedia/cheap'
+import { align as alignFunc } from '@libmedia/common/math'
+
+export function chromaLocation2Pos(pos: AVChromaLocation) {
+  if (pos <= AVChromaLocation.AVCHROMA_LOC_UNSPECIFIED || pos >= AVChromaLocation.AVCHROMA_LOC_NB) {
+    return
+  }
+  return {
+    x: (pos & 1) * 128,
+    y: ((pos >>> 1) ^ (pos < 4 ? 1 : 0)) * 128
+  }
+}
+
+function getMaxPixSteps(desc: AVPixelFormatDescriptor) {
+  const maxPixSteps: int32[] = [0, 0, 0, 0]
+  const maxPixStepsComps: int32[] = [0, 0, 0, 0]
+
+  for (let i = 0; i < 4; i++) {
+    if (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,
+    maxPixStepsComps
+  }
+}
+
+function setSystematicPal(pal: pointer<uint32>, pixfmt: AVPixelFormat) {
+  for (let i = 0; i < 256; i++) {
+    let r: int32, g: int32, b: int32
+
+    switch (pixfmt) {
+      case AVPixelFormat.AV_PIX_FMT_RGB8:
+        r = (i >> 5) * 36
+        g = ((i >> 2) & 7) * 36
+        b = (i & 3) * 85
+        break
+      case AVPixelFormat.AV_PIX_FMT_BGR8:
+        b = (i >> 6) * 85
+        g = ((i >> 3) & 7) * 36
+        r = (i & 7) * 36
+        break
+      case AVPixelFormat.AV_PIX_FMT_RGB4_BYTE:
+        r = (i >> 3) * 255
+        g = ((i >> 1) & 3) * 85
+        b = (i & 1) * 255
+        break
+      case AVPixelFormat.AV_PIX_FMT_BGR4_BYTE:
+        b = (i >> 3) * 255
+        g = ((i >> 1) & 3) * 85
+        r = (i & 1) * 255
+        break
+      case AVPixelFormat.AV_PIX_FMT_GRAY8:
+        r = b = g = i
+        break
+      default:
+        return errorType.INVALID_ARGUMENT
+    }
+    pal[i] = b + (g << 8) + (r << 16) + (0xFF << 24)
+  }
+
+  return 0
+}
+
+function pixelGetLinesize_(width: int32, plane: int32, maxStep: int32, maxStepComp: int32, desc: AVPixelFormatDescriptor) {
+  if (!desc) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  if (width < 0) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  const s = (maxStepComp === 1 || maxStepComp === 2) ? desc.log2ChromaW : 0
+
+  const shiftedW = ((width + (1 << s) - 1)) >>> s
+
+  if (shiftedW && maxStep > INT32_MAX / shiftedW) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  let linesize = maxStep * shiftedW
+
+  if (desc.flags & AVPixelFormatFlags.BIT_STREAM) {
+    linesize = (linesize + 7) >>> 3
+  }
+
+  return linesize
+}
+
+export function pixelGetLinesize(pixfmt: AVPixelFormat, width: int32, plane: int32) {
+  const desc = getAVPixelFormatDescriptor(pixfmt)
+
+  if (!desc) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  const { maxPixSteps, maxPixStepsComps } = getMaxPixSteps(desc)
+
+  return pixelGetLinesize_(width, plane, maxPixSteps[plane], maxPixStepsComps[plane], desc)
+}
+
+export function pixelFillLinesizes(linesizes: pointer<int32>, pixfmt: AVPixelFormat, width: int32) {
+  const desc = getAVPixelFormatDescriptor(pixfmt)
+
+  if (!desc) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  const { maxPixSteps, maxPixStepsComps } = getMaxPixSteps(desc)
+
+  memset(linesizes, 0, 4 * sizeof(linesizes[0]))
+
+  let ret = 0
+
+  for (let i = 0; i < 4; i++) {
+    if ((ret = pixelGetLinesize_(width, i, maxPixSteps[i], maxPixStepsComps[i], desc)) < 0) {
+      return ret
+    }
+    linesizes[i] = ret
+  }
+}
+
+export function pixelFillPlaneSizes(sizes: pointer<size>, pixfmt: AVPixelFormat, height: int32, linesizes: pointer<int32>) {
+  const hasPlane = [0, 0, 0, 0]
+
+  const desc = getAVPixelFormatDescriptor(pixfmt)
+
+  if (!desc) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  memset(sizes, 0, 4 * sizeof(sizes[0]))
+
+  if (linesizes[0] > INT32_MAX / height) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  sizes[0] = reinterpret_cast<size>(linesizes[0] * height)
+
+  if (desc.flags & AVPixelFormatFlags.PALETTE) {
+    sizes[1] = reinterpret_cast<size>(256 * 4)
+    return 0
+  }
+
+  for (let i = 0; i < 4; i++) {
+    if (desc.comp[i]) {
+      hasPlane[desc.comp[i].plane] = 1
+    }
+  }
+
+  for (let i = 0; i < 4 && hasPlane[i]; i++) {
+    let s = (i === 1 || i === 2) ? desc.log2ChromaH : 0
+    let h = (height + (1 << s) - 1) >> s
+
+    if (linesizes[i] > INT32_MAX / h) {
+      return errorType.INVALID_ARGUMENT
+    }
+
+    sizes[i] = reinterpret_cast<size>(h * linesizes[i])
+  }
+  return 0
+}
+
+export function pixelFillPointer(
+  data: pointer<pointer<uint8>>,
+  pixfmt: AVPixelFormat,
+  height: int32,
+  ptr: pointer<uint8>,
+  linesizes: pointer<int32>
+) {
+  const linesizes1 = reinterpret_cast<pointer<int32>>(stack.malloc(sizeof(linesizes[0]) * 4))
+  const sizes = reinterpret_cast<pointer<size>>(stack.malloc(sizeof(size) * 4))
+
+  memset(data, 0, 4 * sizeof(data[0]))
+
+  for (let i = 0; i < 4; i++) {
+    linesizes1[i] = linesizes[i]
+  }
+
+  let ret = pixelFillPlaneSizes(sizes, pixfmt, height, linesizes1)
+
+  if (ret < 0) {
+    defer()
+    return ret
+  }
+
+  ret = 0
+
+  for (let i = 0; i < 4; i++) {
+    if (sizes[i] > INT32_MAX - ret) {
+      defer()
+      return errorType.INVALID_ARGUMENT
+    }
+    ret += reinterpret_cast<double>(sizes[i])
+  }
+
+  if (!ptr) {
+    defer()
+    return ret
+  }
+
+  data[0] = ptr
+  for (let i = 1; i < 4 && sizes[i]; i++) {
+    data[i] = reinterpret_cast<pointer<uint8>>(data[i - 1] + sizes[i - 1])
+  }
+
+  defer()
+  return ret
+
+  function defer() {
+    stack.free(sizeof(linesizes[0]) * 4)
+    stack.free(sizeof(size) * 4)
+  }
+}
+
+export function pixelAlloc(
+  pointers: pointer<pointer<uint8>>,
+  linesizes: pointer<int32>,
+  w: int32,
+  h: int32,
+  pixfmt: AVPixelFormat,
+  align: int32 = 1
+) {
+
+  const desc = getAVPixelFormatDescriptor(pixfmt)
+
+  if (!desc) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  const linesizes1 = reinterpret_cast<pointer<int32>>(stack.malloc(sizeof(linesizes[0]) * 4))
+  const sizes = reinterpret_cast<pointer<size>>(stack.malloc(sizeof(size) * 4))
+
+  let ret = 0
+
+  if ((ret = pixelFillLinesizes(linesizes, pixfmt, align > 7 ? alignFunc(w, 8) : w)) < 0) {
+    defer()
+    return ret
+  }
+
+  for (let i = 0; i < 4; i++) {
+    linesizes[i] = alignFunc(linesizes[i], align)
+    linesizes1[i] = linesizes[i]
+  }
+
+  if ((ret = pixelFillPlaneSizes(sizes, pixfmt, h, linesizes1)) < 0) {
+    defer()
+    return ret
+  }
+
+  let totalSize: size = static_cast<size>(align)
+
+  for (let i = 0; i < 4; i++) {
+    if (totalSize > static_cast<size>(INT32_MAX) - sizes[i]) {
+      defer()
+      return errorType.INVALID_ARGUMENT
+    }
+    totalSize += sizes[i]
+  }
+
+  const buf: pointer<uint8> = avMalloc(totalSize)
+
+  if (!buf) {
+    defer()
+    return errorType.NO_MEMORY
+  }
+
+  if ((ret = pixelFillPointer(pointers, pixfmt, h, buf, linesizes)) < 0) {
+    defer()
+    return ret
+  }
+
+  if (desc.flags & AVPixelFormatFlags.PALETTE) {
+    if (align < 4) {
+      avFree(buf)
+      defer()
+      return ret
+    }
+    setSystematicPal(reinterpret_cast<pointer<uint32>>(pointers[1]), pixfmt)
+  }
+
+  if ((desc.flags & AVPixelFormatFlags.PALETTE)
+    && pointers[1]
+    && pointers[1] - pointers[0] > linesizes[0] * h
+  ) {
+    /* zero-initialize the padding before the palette */
+    memset(pointers[0] + linesizes[0] * h, 0, pointers[1] - pointers[0] - linesizes[0] * h)
+  }
+
+  defer()
+  return ret
+
+  function defer() {
+    stack.free(sizeof(linesizes[0]) * 4)
+    stack.free(sizeof(size) * 4)
+  }
+}
+
+export function pixelGetSize(pixfmt: AVPixelFormat, width: int32, height: int32, align: int32) {
+  const desc = getAVPixelFormatDescriptor(pixfmt)
+
+  if (!desc) {
+    return errorType.INVALID_ARGUMENT
+  }
+
+  const linesizes = reinterpret_cast<pointer<int32>>(stack.malloc(sizeof(int32) * 4))
+  const alignedLinesizes = reinterpret_cast<pointer<int32>>(stack.malloc(sizeof(int32) * 4))
+  const sizes = reinterpret_cast<pointer<size>>(stack.malloc(sizeof(size) * 4))
+
+  let ret = 0
+
+  if ((ret = pixelFillLinesizes(linesizes, pixfmt, width)) < 0) {
+    defer()
+    return ret
+  }
+
+  for (let i = 0; i < 4; i++) {
+    alignedLinesizes[i] = alignFunc(linesizes[i], align)
+  }
+
+  if ((ret = pixelFillPlaneSizes(sizes, pixfmt, height, alignedLinesizes)) < 0) {
+    defer()
+    return ret
+  }
+
+  let totalSize: size = 0
+
+  for (let i = 0; i < 4; i++) {
+    if (totalSize > reinterpret_cast<size>(INT32_MAX) - sizes[i]) {
+      defer()
+      return errorType.INVALID_ARGUMENT
+    }
+    totalSize += sizes[i]
+  }
+
+  defer()
+
+  return totalSize
+
+  function defer() {
+    stack.free(sizeof(int32) * 4)
+    stack.free(sizeof(int32) * 4)
+    stack.free(sizeof(size) * 4)
+  }
+}

package/src/util/rational.ts

@@ -0,0 +1,152 @@
+/*
+ * libmedia rational util
+ *
+ * 版权所有 (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 { INT32_MAX } from '../constant'
+import type { AVRational } from '../struct/rational'
+import { gcd } from '@libmedia/common/math'
+
+/**
+ * 将一个时间戳由一个时间基转换到另一个时间基
+ * 
+ * @param a 待转换时间戳
+ * @param bp 待转换时间戳的时间基
+ * @param cq 目标时间基
+ */
+export function avRescaleQ(a: int64, bq: AVRational, cq: AVRational) {
+  const b = a * static_cast<int64>(bq.num as unknown as uint32) * static_cast<int64>(cq.den as unknown as uint32)
+  const c = static_cast<int64>(bq.den as unknown as uint32) * static_cast<int64>(cq.num as unknown as uint32)
+  return b / c
+}
+
+/**
+ * 将一个时间戳由一个时间基转换到另一个时间基
+ * 
+ * @param a 待转换时间戳
+ * @param bp 待转换时间戳的时间基
+ * @param cq 目标时间基
+ */
+export function avRescaleQ2(a: int64, bq: pointer<AVRational>, cq: AVRational) {
+  const b = a * static_cast<int64>(bq.num as unknown as uint32) * static_cast<int64>(cq.den as unknown as uint32)
+  const c = static_cast<int64>(bq.den as unknown as uint32) * static_cast<int64>(cq.num as unknown as uint32)
+  return b / c
+}
+
+/**
+ * 将一个时间戳由一个时间基转换到另一个时间基
+ * 
+ * @param a 待转换时间戳
+ * @param bp 待转换时间戳的时间基
+ * @param cq 目标时间基
+ */
+export function avRescaleQ3(a: int64, bq: AVRational, cq: pointer<AVRational>) {
+  const b = a * static_cast<int64>(bq.num as unknown as uint32) * static_cast<int64>(cq.den as unknown as uint32)
+  const c = static_cast<int64>(bq.den as unknown as uint32) * static_cast<int64>(cq.num as unknown as uint32)
+  return b / c
+}
+
+/**
+ * 将一个时间戳由一个时间基转换到另一个时间基
+ * 
+ * @param a 待转换时间戳
+ * @param bp 待转换时间戳的时间基
+ * @param cq 目标时间基
+ */
+export function avRescaleQ4(a: int64, bq: pointer<AVRational>, cq: pointer<AVRational>) {
+  const b = a * static_cast<int64>(bq.num as unknown as uint32) * static_cast<int64>(cq.den as unknown as uint32)
+  const c = static_cast<int64>(bq.den as unknown as uint32) * static_cast<int64>(cq.num as unknown as uint32)
+  return b / c
+}
+
+/**
+ * 将一个时间基转换成 double
+ * 
+ * @param a 
+ */
+export function avQ2D(a: AVRational) {
+  return a.num / a.den
+}
+
+/**
+ * 将一个时间基转换成 double
+ * 
+ * @param a 
+ */
+export function avQ2D2(a: pointer<AVRational>) {
+  return a.num / a.den
+}
+
+export function avD2Q(d: double, max: int32): AVRational {
+  if (isNaN(double)) {
+    return {
+      den: 0,
+      num: 0
+    }
+  }
+  if (Math.abs(d) > INT32_MAX + 3) {
+    return {
+      den: 0,
+      num: d < 0 ? -1 : 1
+    }
+  }
+  const q = d > 1
+    ? {
+      den: Math.floor(max / d + 0.5),
+      num: max
+    }
+    : {
+      den: max,
+      num: Math.floor(d * max + 0.5)
+    }
+  avReduce(q)
+  return q
+}
+
+/**
+ * 化简 Rational
+ * 
+ * @param a 
+ */
+export function avReduce(a: AVRational) {
+  const gcdValue = gcd(a.num, a.den)
+  if (gcdValue <= 1) {
+    return
+  }
+  a.den /= gcdValue
+  a.num /= gcdValue
+}
+
+/**
+ * 化简 Rational
+ * 
+ * @param a 
+ */
+export function avReduce2(a: pointer<AVRational>) {
+  const gcdValue = gcd(a.num, a.den)
+  if (gcdValue <= 1) {
+    return
+  }
+  a.den /= gcdValue
+  a.num /= gcdValue
+}

package/src/util/sample.ts

@@ -0,0 +1,136 @@
+/*
+ * libmedia audio sample util
+ *
+ * 版权所有 (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 { memset } from '@libmedia/cheap'
+import { AVSampleFormat } from '../audiosamplefmt'
+import { INT32_MAX } from '../constant'
+import { avFree, avMalloc } from '../util/mem'
+import { AVSampleFormatDescriptors } from '../sampleFormatDescriptor'
+
+import { align as alignFunc } from '@libmedia/common/math'
+
+export function getBytesPerSample(format: AVSampleFormat) {
+  return (format < 0 || format >= AVSampleFormat.AV_SAMPLE_FMT_NB)
+    ? 0
+    : AVSampleFormatDescriptors[format].bits >> 3
+}
+
+export function sampleFormatIsPlanar(format: AVSampleFormat) {
+  return (format < 0 || format >= AVSampleFormat.AV_SAMPLE_FMT_NB)
+    ? false
+    : AVSampleFormatDescriptors[format].planar
+}
+
+export function sampleFormatGetLinesize(format: AVSampleFormat, channels: int32, nbSamples: int32, align?: int32) {
+  const sampleSize = getBytesPerSample(format)
+  const planar = sampleFormatIsPlanar(format)
+
+  if (!sampleSize || nbSamples <= 0 || channels <= 0) {
+    return -1
+  }
+
+  if (!align) {
+    align = 1
+    nbSamples = alignFunc(nbSamples, 32)
+  }
+
+  if (channels > INT32_MAX / align || channels * nbSamples > (INT32_MAX - align * channels) / sampleSize) {
+    return -1
+  }
+
+  return planar ? alignFunc(nbSamples * sampleSize, align) : alignFunc(nbSamples * sampleSize * channels, align)
+}
+
+export function sampleFillArrays(
+  audioData: pointer<pointer<uint8>>,
+  buf: pointer<uint8>,
+  format: AVSampleFormat,
+  linesize: int32,
+  channels: int32
+) {
+  const planar = sampleFormatIsPlanar(format)
+
+  memset(audioData, 0, planar ? reinterpret_cast<int32>(sizeof(accessof(audioData))) * channels : sizeof(accessof(audioData)))
+
+  if (!buf) {
+    return -1
+  }
+
+  audioData[0] = buf
+
+  if (planar) {
+    for (let i = 1; i < channels; i++) {
+      audioData[i] = reinterpret_cast<pointer<uint8>>(audioData[i - 1] + linesize)
+    }
+  }
+  return 0
+}
+
+export function sampleAlloc(
+  audioData: pointer<pointer<uint8>>,
+  format: AVSampleFormat,
+  linesize: int32,
+  channels: int32
+) {
+  const planar = sampleFormatIsPlanar(format)
+  const bufSize = planar ? linesize * channels : linesize
+
+  if (bufSize < 0) {
+    return bufSize
+  }
+
+  const buf: pointer<uint8> = avMalloc(bufSize)
+
+  const ret = sampleFillArrays(audioData, buf, format, linesize, channels)
+
+  if (ret < 0) {
+    avFree(buf)
+    return ret
+  }
+
+  return 0
+}
+
+export function sampleSetSilence(
+  audioData: pointer<pointer<uint8>>,
+  offset: int32,
+  format: AVSampleFormat,
+  nbSamples: int32,
+  channels: int32
+) {
+  const planar = sampleFormatIsPlanar(format)
+  const planes = planar ? channels : 1
+  const blockAlign = getBytesPerSample(format) * (planar ? 1 : channels)
+  const dataSize = nbSamples * blockAlign
+  const fillChar = (format === AVSampleFormat.AV_SAMPLE_FMT_U8 || format === AVSampleFormat.AV_SAMPLE_FMT_U8P)
+    ? 0x80
+    : 0x00
+
+  offset *= blockAlign
+
+  for (let i = 0; i < planes; i++) {
+    memset(audioData[i] + offset, fillChar, dataSize)
+  }
+}