@libmedia/avutil 0.12.0 → 1.0.1

package/src/util/nalu.ts

@@ -0,0 +1,297 @@
+/*
+ * libmedia nalu 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 { SafeUint8Array } from '@libmedia/cheap'
+
+import { array } from '@libmedia/common'
+
+import {
+  BufferWriter,
+  BufferReader,
+  type Uint8ArrayInterface
+} from '@libmedia/common/io'
+
+export function isAnnexb(data: Uint8ArrayInterface) {
+  return data.length > 4
+  && data[0] === 0
+  && data[1] === 0
+  && (
+    data[2] === 1
+    || data[2] === 0 && data[3] === 1
+  )
+}
+
+export function getNextNaluStart(data: Uint8ArrayInterface, offset: number) {
+  let t = 0
+  for (let i = offset; i < data.length; i++) {
+    switch (data[i]) {
+      case 0:
+        t++
+        break
+      case 1:
+        if (t >= 2) {
+          return {
+            offset: i - Math.min(t, 3),
+            startCode: Math.min(t + 1, 4)
+          }
+        }
+        t = 0
+        break
+      default:
+        t = 0
+    }
+  }
+  return {
+    offset: -1,
+    startCode: 0
+  }
+}
+
+export function splitNaluByStartCode<T extends Uint8ArrayInterface>(buffer: T): T[] {
+  const list = []
+  let offset = 0
+  if (buffer instanceof SafeUint8Array) {
+    buffer = buffer.subarray(0, buffer.length, false) as T
+  }
+  let current = getNextNaluStart(buffer, offset)
+  let next = {
+    offset: -1,
+    startCode: 0
+  }
+  while (next = getNextNaluStart(buffer, current.offset + current.startCode), next.offset > -1) {
+    list.push(buffer.subarray(current.offset + current.startCode, next.offset, true))
+    current = next
+  }
+  list.push(buffer.subarray(current.offset + current.startCode, undefined, true))
+
+  return list
+}
+
+export function splitNaluByLength<T extends Uint8ArrayInterface>(buffer: T, naluLengthSizeMinusOne: int32): T[] {
+  const list = []
+  const bufferReader = new BufferReader(buffer)
+  while (bufferReader.remainingSize() > 0) {
+    let length = 0
+    if (naluLengthSizeMinusOne === 3) {
+      length = bufferReader.readUint32()
+    }
+    else if (naluLengthSizeMinusOne === 2) {
+      length = bufferReader.readUint24()
+    }
+    else if (naluLengthSizeMinusOne === 1) {
+      length = bufferReader.readUint16()
+    }
+    else {
+      length = bufferReader.readUint8()
+    }
+    const nalu = buffer.subarray(static_cast<int32>(bufferReader.getPos()), static_cast<int32>(bufferReader.getPos()) + length, true)
+    bufferReader.skip(length)
+    list.push(nalu)
+  }
+  return list
+}
+
+/**
+ * 
+ * @param nalus 
+ * @param mode 模式
+ *  - 0 全使用 0x00000001 分割
+ *  - 1 全使用 0x000001 分割
+ *  - 2 第一个使用 0x00000001，后面的使用 0x000001 分割
+ * @returns 
+ */
+export function joinNaluByStartCodeLength(nalus: Uint8ArrayInterface[], mode: int32) {
+  return nalus.reduce((prev, nalu, index) => {
+    if (mode === 0) {
+      return prev + 4 + nalu.length
+    }
+    else if ( mode === 1) {
+      return prev + 3 + nalu.length
+    }
+    else {
+      return prev + (index ? 3 : 4) + nalu.length
+    }
+  }, 0)
+}
+
+/**
+ * 
+ * @param nalus 
+ * @param mode 模式
+ *  - 0 全使用 0x00000001 分割
+ *  - 1 全使用 0x000001 分割
+ *  - 2 第一个使用 0x00000001，后面的使用 0x000001 分割
+ * @param output 
+ * @returns 
+ */
+export function joinNaluByStartCode(nalus: Uint8ArrayInterface[], mode: int32, output?: Uint8Array): Uint8Array {
+  if (!output) {
+    let length = nalus.reduce((prev, nalu, index) => {
+      if (mode === 0) {
+        return prev + 4 + nalu.length
+      }
+      else if ( mode === 1) {
+        return prev + 3 + nalu.length
+      }
+      else {
+        return prev + (index ? 3 : 4) + nalu.length
+      }
+    }, 0)
+    output = new Uint8Array(length)
+  }
+
+  const bufferWriter = new BufferWriter(output)
+
+  array.each(nalus, (nalu, index) => {
+    bufferWriter.writeUint8(0x00)
+    bufferWriter.writeUint8(0x00)
+    if (mode === 0 || (mode === 2 && !index)) {
+      bufferWriter.writeUint8(0x00)
+    }
+    bufferWriter.writeUint8(0x01)
+    bufferWriter.writeBuffer(nalu)
+  })
+
+  return output
+}
+
+export function joinNaluByLength(nalus: Uint8ArrayInterface[], naluLengthSizeMinusOne: int32, output?: Uint8Array): Uint8Array {
+  if (!output) {
+    const length = nalus.reduce((prev, nalu) => {
+      return prev + naluLengthSizeMinusOne + 1 + nalu.length
+    }, 0)
+    output = new Uint8Array(length)
+  }
+  const bufferWriter = new BufferWriter(output)
+
+  array.each(nalus, (nalu) => {
+    if (naluLengthSizeMinusOne === 3) {
+      bufferWriter.writeUint32(nalu.length)
+    }
+    else if (naluLengthSizeMinusOne === 2) {
+      bufferWriter.writeUint24(nalu.length)
+    }
+    else if (naluLengthSizeMinusOne === 1) {
+      bufferWriter.writeUint16(nalu.length)
+    }
+    else {
+      bufferWriter.writeUint8(nalu.length)
+    }
+    bufferWriter.writeBuffer(nalu)
+  })
+  return output
+}
+
+export function naluUnescape(data: Uint8Array, start = 0, end?: number) {
+
+  if (!end) {
+    end = data.length
+  }
+
+  const buffer = new Uint8Array(data.length)
+
+  let zeroCount = 0
+  let pos = 0
+  for (let i = 0; i < data.length; i++) {
+    if (i >= start && i < end) {
+      if (data[i] === 0) {
+        zeroCount++
+      }
+      else {
+        if (data[i] === 3 && zeroCount === 2 && i + 1 < data.length && data[i + 1] <= 3) {
+          i++
+          if (i === data.length) {
+            break
+          }
+          else {
+            if (data[i] === 0) {
+              zeroCount = 1
+            }
+            else {
+              zeroCount = 0
+            }
+          }
+        }
+        else {
+          zeroCount = 0
+        }
+      }
+    }
+    buffer[pos++] = data[i]
+  }
+
+  return buffer.slice(0, pos)
+}
+
+export function naluEscape(data: Uint8Array, start: number = 0, end?: number) {
+  if (!end) {
+    end = data.length
+  }
+
+  const indexes = []
+  let zeroCount = 0
+  for (let i = start; i < end; i++) {
+
+    if (i >= end) {
+      break
+    }
+
+    if (data[i] === 0) {
+      zeroCount++
+    }
+    else {
+      if (data[i] <= 3 && zeroCount === 2) {
+        indexes.push(i)
+      }
+      zeroCount = 0
+    }
+  }
+
+  if (indexes.length) {
+    const buffer = new Uint8Array(data.length + indexes.length)
+    let pos = 0
+    let subData = data.subarray(0, indexes[0])
+    buffer.set(subData, pos)
+    pos += subData.length
+
+    buffer[pos++] = 3
+
+    for (let i = 1; i < indexes.length; i++) {
+      subData = data.subarray(indexes[i - 1], indexes[i])
+      buffer.set(subData, pos)
+      pos += subData.length
+      buffer[pos++] = 3
+    }
+
+    subData = data.subarray(indexes[indexes.length - 1], data.length)
+    buffer.set(subData, pos)
+    pos += subData.length
+
+    return buffer
+  }
+  else {
+    return data
+  }
+}

package/src/util/ntp.ts

@@ -0,0 +1,32 @@
+/*
+ * libmedia ntp 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.
+ *
+ */
+
+
+export function parse(ntp: uint64) {
+  const sec = ntp >> 32n
+  const fracPart = ntp & 0xFFFFFFFFn
+  const usec = (fracPart * 1000000n) / 0xFFFFFFFFn
+  return (sec * 1000000n) + usec
+}

package/src/util/pcm.ts

@@ -0,0 +1,161 @@
+/*
+ * libmedia pcm 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 { AVCodecID } from '../codec'
+
+export function getPcmCodecId(bps: int32, flt: boolean, be: boolean, flags: int32) {
+  if (bps <= 0 || bps > 64) {
+    return AVCodecID.AV_CODEC_ID_NONE
+  }
+
+  if (flt) {
+    switch (bps) {
+      case 32:
+        return be ? AVCodecID.AV_CODEC_ID_PCM_F32BE : AVCodecID.AV_CODEC_ID_PCM_F32LE
+      case 64:
+        return be ? AVCodecID.AV_CODEC_ID_PCM_F64BE : AVCodecID.AV_CODEC_ID_PCM_F64LE
+      default:
+        return AVCodecID.AV_CODEC_ID_NONE
+    }
+  }
+  else {
+    bps += 7
+    bps >>>= 3
+
+    if (flags & (1 << (bps - 1))) {
+      switch (bps) {
+        case 1:
+          return AVCodecID.AV_CODEC_ID_PCM_S8
+        case 2:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_S16BE : AVCodecID.AV_CODEC_ID_PCM_S16LE
+        case 3:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_S24BE : AVCodecID.AV_CODEC_ID_PCM_S24LE
+        case 4:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_S32BE : AVCodecID.AV_CODEC_ID_PCM_S32LE
+        case 8:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_S64BE : AVCodecID.AV_CODEC_ID_PCM_S64LE
+        default:
+          return AVCodecID.AV_CODEC_ID_NONE
+      }
+    }
+    else {
+      switch (bps) {
+        case 1:
+          return AVCodecID.AV_CODEC_ID_PCM_U8
+        case 2:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_U16BE : AVCodecID.AV_CODEC_ID_PCM_U16LE
+        case 3:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_U24BE : AVCodecID.AV_CODEC_ID_PCM_U24LE
+        case 4:
+          return be ? AVCodecID.AV_CODEC_ID_PCM_U32BE : AVCodecID.AV_CODEC_ID_PCM_U32LE
+        default:
+          return AVCodecID.AV_CODEC_ID_NONE
+      }
+    }
+  }
+}
+
+export function getExactBitsPerSample(codecId: AVCodecID) {
+  switch (codecId) {
+    case AVCodecID.AV_CODEC_ID_8SVX_EXP:
+    case AVCodecID.AV_CODEC_ID_8SVX_FIB:
+    case AVCodecID.AV_CODEC_ID_ADPCM_ARGO:
+    case AVCodecID.AV_CODEC_ID_ADPCM_CT:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_ALP:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_AMV:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_APC:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_APM:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_OKI:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_WS:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_SSI:
+    case AVCodecID.AV_CODEC_ID_ADPCM_G722:
+    case AVCodecID.AV_CODEC_ID_ADPCM_YAMAHA:
+    case AVCodecID.AV_CODEC_ID_ADPCM_AICA:
+      return 4
+    case AVCodecID.AV_CODEC_ID_DSD_LSBF:
+    case AVCodecID.AV_CODEC_ID_DSD_MSBF:
+    case AVCodecID.AV_CODEC_ID_DSD_LSBF_PLANAR:
+    case AVCodecID.AV_CODEC_ID_DSD_MSBF_PLANAR:
+    case AVCodecID.AV_CODEC_ID_PCM_ALAW:
+    case AVCodecID.AV_CODEC_ID_PCM_MULAW:
+    case AVCodecID.AV_CODEC_ID_PCM_VIDC:
+    case AVCodecID.AV_CODEC_ID_PCM_S8:
+    case AVCodecID.AV_CODEC_ID_PCM_S8_PLANAR:
+    case AVCodecID.AV_CODEC_ID_PCM_SGA:
+    case AVCodecID.AV_CODEC_ID_PCM_U8:
+    case AVCodecID.AV_CODEC_ID_SDX2_DPCM:
+    case AVCodecID.AV_CODEC_ID_DERF_DPCM:
+      return 8
+    case AVCodecID.AV_CODEC_ID_PCM_S16BE:
+    case AVCodecID.AV_CODEC_ID_PCM_S16BE_PLANAR:
+    case AVCodecID.AV_CODEC_ID_PCM_S16LE:
+    case AVCodecID.AV_CODEC_ID_PCM_S16LE_PLANAR:
+    case AVCodecID.AV_CODEC_ID_PCM_U16BE:
+    case AVCodecID.AV_CODEC_ID_PCM_U16LE:
+      return 16
+    case AVCodecID.AV_CODEC_ID_PCM_S24DAUD:
+    case AVCodecID.AV_CODEC_ID_PCM_S24BE:
+    case AVCodecID.AV_CODEC_ID_PCM_S24LE:
+    case AVCodecID.AV_CODEC_ID_PCM_S24LE_PLANAR:
+    case AVCodecID.AV_CODEC_ID_PCM_U24BE:
+    case AVCodecID.AV_CODEC_ID_PCM_U24LE:
+      return 24
+    case AVCodecID.AV_CODEC_ID_PCM_S32BE:
+    case AVCodecID.AV_CODEC_ID_PCM_S32LE:
+    case AVCodecID.AV_CODEC_ID_PCM_S32LE_PLANAR:
+    case AVCodecID.AV_CODEC_ID_PCM_U32BE:
+    case AVCodecID.AV_CODEC_ID_PCM_U32LE:
+    case AVCodecID.AV_CODEC_ID_PCM_F32BE:
+    case AVCodecID.AV_CODEC_ID_PCM_F32LE:
+    case AVCodecID.AV_CODEC_ID_PCM_F24LE:
+    case AVCodecID.AV_CODEC_ID_PCM_F16LE:
+      return 32
+    case AVCodecID.AV_CODEC_ID_PCM_F64BE:
+    case AVCodecID.AV_CODEC_ID_PCM_F64LE:
+    case AVCodecID.AV_CODEC_ID_PCM_S64BE:
+    case AVCodecID.AV_CODEC_ID_PCM_S64LE:
+      return 64
+    default:
+      return 0
+  }
+}
+
+export function getBitsPerSample(codecId: AVCodecID) {
+  switch (codecId) {
+    case AVCodecID.AV_CODEC_ID_ADPCM_SBPRO_2:
+      return 2
+    case AVCodecID.AV_CODEC_ID_ADPCM_SBPRO_3:
+      return 3
+    case AVCodecID.AV_CODEC_ID_ADPCM_SBPRO_4:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_WAV:
+    case AVCodecID.AV_CODEC_ID_ADPCM_IMA_QT:
+    case AVCodecID.AV_CODEC_ID_ADPCM_SWF:
+    case AVCodecID.AV_CODEC_ID_ADPCM_MS:
+      return 4
+    default:
+      return getExactBitsPerSample(codecId)
+  }
+}