@libmedia/avutil 0.12.0 → 1.0.1

package/src/util/avpacket.ts

@@ -0,0 +1,313 @@
+/*
+ * libmedia avpacket 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 AVPacket, { AVPacketSideData } from '../struct/avpacket'
+import type { AVPacketSideDataType } from '../codec'
+import { avFree, avFreep, avMalloc, avMallocz } from './mem'
+import { AV_TIME_BASE, NOPTS_VALUE, NOPTS_VALUE_BIGINT } from '../constant'
+import { avbufferCreate, avbufferRealloc, avbufferRef, avbufferReplace, avbufferUnref } from './avbuffer'
+import type { AVBufferRef } from '../struct/avbuffer'
+
+import {
+  type SafeUint8Array,
+  memcpy,
+  memset,
+  mapUint8Array,
+  mapSafeUint8Array
+} from '@libmedia/cheap'
+
+const AV_INPUT_BUFFER_PADDING_SIZE = 64
+
+export function getAVPacketData(avpacket: pointer<AVPacket>): Uint8Array<ArrayBufferLike>
+export function getAVPacketData(avpacket: pointer<AVPacket>, safe: boolean): SafeUint8Array
+export function getAVPacketData(avpacket: pointer<AVPacket>, safe?: boolean) {
+  return safe ? mapSafeUint8Array(avpacket.data, reinterpret_cast<size>(avpacket.size)) : mapUint8Array(avpacket.data, reinterpret_cast<size>(avpacket.size))
+}
+
+export function initAVPacketData(avpacket: pointer<AVPacket>, length: size) {
+  avpacket.data = avMalloc(length)
+  avpacket.size = static_cast<int32>(length)
+  return mapUint8Array(avpacket.data, reinterpret_cast<size>(avpacket.size))
+}
+
+export function getSideData(psd: pointer<pointer<AVPacketSideData>>, pnbSd: pointer<int32>, type: AVPacketSideDataType): pointer<AVPacketSideData> {
+  const sideDataElems = accessof(pnbSd)
+  const sideData = accessof(psd)
+  for (let i = 0; i < sideDataElems; i++) {
+    if (sideData[i].type === type) {
+      return addressof(sideData[i])
+    }
+  }
+  return nullptr
+}
+
+export function getAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType): pointer<AVPacketSideData> {
+  return getSideData(addressof(avpacket.sideData), addressof(avpacket.sideDataElems), type)
+}
+
+export function hasSideData(psd: pointer<pointer<AVPacketSideData>>, pnbSd: pointer<int32>, type: AVPacketSideDataType) {
+  const sideDataElems = accessof(pnbSd)
+  const sideData = accessof(psd)
+  for (let i = 0; i < sideDataElems; i++) {
+    if (sideData[i].type === type) {
+      return true
+    }
+  }
+  return false
+}
+
+export function hasAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType) {
+  return hasSideData(addressof(avpacket.sideData), addressof(avpacket.sideDataElems), type)
+}
+
+export function addSideData(psd: pointer<pointer<AVPacketSideData>>, pnbSd: pointer<int32>, type: AVPacketSideDataType, data: pointer<void>, length: size) {
+  const sideDataElems = accessof(pnbSd)
+  const sideData = accessof(psd)
+  for (let i = 0; i < sideDataElems; i++) {
+    if (sideData[i].type === type) {
+      avFree(sideData[i].data)
+      sideData[i].data = reinterpret_cast<pointer<uint8>>(data)
+      sideData[i].size = length
+      return
+    }
+  }
+  const len = (sideDataElems + 1) * reinterpret_cast<int32>(sizeof(AVPacketSideData))
+  const newSideData = avMallocz(len) as pointer<AVPacketSideData>
+
+  if (sideDataElems) {
+    for (let i = 0; i < sideDataElems; i++) {
+      newSideData[i] = sideData[i]
+    }
+  }
+
+  const ele = addressof(newSideData[sideDataElems])
+  ele.data = reinterpret_cast<pointer<uint8>>(data)
+  ele.type = type
+  ele.size = length
+
+  if (sideData) {
+    avFree(sideData)
+  }
+
+  accessof(psd) <- newSideData
+  accessof(pnbSd) <- reinterpret_cast<int32>(sideDataElems + 1)
+
+  return ele
+}
+
+export function newSideData(psd: pointer<pointer<AVPacketSideData>>, pnbSd: pointer<int32>, type: AVPacketSideDataType, size: size) {
+  const data = avMalloc(size + static_cast<size>(AV_INPUT_BUFFER_PADDING_SIZE as uint32))
+  memset(reinterpret_cast<pointer<uint8>>(data + size), 0, AV_INPUT_BUFFER_PADDING_SIZE)
+  return addSideData(psd, pnbSd, type, data, size)
+}
+
+export function addAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType, data: pointer<void>, length: size) {
+  addSideData(addressof(avpacket.sideData), addressof(avpacket.sideDataElems), type, data, length)
+}
+
+export function deleteAVPacketSideData(avpacket: pointer<AVPacket>, type: AVPacketSideDataType) {
+  let index = -1
+  for (let i = 0; i < avpacket.sideDataElems; i++) {
+    if (avpacket.sideData[i].type === type) {
+      index = i
+      break
+    }
+  }
+  if (index > -1) {
+    if (avpacket.sideDataElems === 1) {
+      avFree(avpacket.sideData[0].data)
+      avFree(avpacket.sideData)
+      avpacket.sideData = nullptr
+      avpacket.sideDataElems = 0
+    }
+    else {
+      const len = (avpacket.sideDataElems - 1) * reinterpret_cast<int32>(sizeof(AVPacketSideData))
+      const sideData = avMallocz(len) as pointer<AVPacketSideData>
+      for (let i = 0; i < avpacket.sideDataElems; i++) {
+        if (i !== index) {
+          sideData[i] = avpacket.sideData[i]
+        }
+        else {
+          avFree(avpacket.sideData[i].data)
+        }
+      }
+      avFree(avpacket.sideData)
+      avpacket.sideData = sideData
+      avpacket.sideDataElems--
+    }
+  }
+}
+
+export function createAVPacket(): pointer<AVPacket> {
+  const avpacket = reinterpret_cast<pointer<AVPacket>>(avMallocz(sizeof(AVPacket)))
+  getAVPacketDefault(avpacket)
+  return avpacket
+}
+
+export function destroyAVPacket(avpacket: pointer<AVPacket>) {
+  unrefAVPacket(avpacket)
+  avFree(avpacket)
+}
+
+export function freeAVPacketSideData(pSideData: pointer<pointer<AVPacketSideData>>, pnbSideData: pointer<int32>) {
+
+  const sideData = accessof(pSideData)
+  const nbSideData = accessof(pnbSideData)
+
+  if (sideData) {
+    for (let i = 0; i < nbSideData; i++) {
+      avFree(sideData[i].data)
+    }
+    avFreep(pSideData)
+    accessof(pnbSideData) <- static_cast<int32>(0)
+  }
+}
+
+export function getAVPacketDefault(avpacket: pointer<AVPacket>) {
+  avpacket.data = nullptr
+  avpacket.size = 0
+  avpacket.sideData = nullptr
+  avpacket.sideDataElems = 0
+  avpacket.streamIndex = NOPTS_VALUE
+  avpacket.pos = NOPTS_VALUE_BIGINT
+  avpacket.duration = NOPTS_VALUE_BIGINT
+  avpacket.flags = 0
+  avpacket.dts = NOPTS_VALUE_BIGINT
+  avpacket.pts = NOPTS_VALUE_BIGINT
+  avpacket.timeBase.den = AV_TIME_BASE
+  avpacket.timeBase.num = 1
+
+  avpacket.buf = nullptr
+}
+
+export function copyAVPacketSideData(dst: pointer<AVPacket>, src: pointer<AVPacket>) {
+  freeAVPacketSideData(addressof(dst.sideData), addressof(dst.sideDataElems))
+  if (src.sideDataElems) {
+    let size = reinterpret_cast<int32>(sizeof(AVPacketSideData))
+    dst.sideData = reinterpret_cast<pointer<AVPacketSideData>>(avMallocz(size * src.sideDataElems))
+    for (let i = 0; i < src.sideDataElems; i++) {
+      dst.sideData[i].size = src.sideData[i].size
+      dst.sideData[i].type = src.sideData[i].type
+      dst.sideData[i].data = avMalloc(src.sideData[i].size)
+      memcpy(dst.sideData[i].data, src.sideData[i].data, src.sideData[i].size)
+    }
+    dst.sideDataElems = src.sideDataElems
+  }
+}
+
+export function copyAVPacketProps(dst: pointer<AVPacket>, src: pointer<AVPacket>) {
+  dst.streamIndex = src.streamIndex
+  dst.pos = src.pos
+  dst.duration = src.duration
+  dst.flags = src.flags
+  dst.dts = src.dts
+  dst.pts = src.pts
+  dst.opaque = src.opaque
+  dst.timeBase.den = src.timeBase.den
+  dst.timeBase.num = src.timeBase.num
+
+  dst.opaqueRef = nullptr
+
+  avbufferReplace(addressof(dst.opaqueRef), src.opaqueRef)
+
+  copyAVPacketSideData(dst, src)
+
+  return 0
+}
+
+function allocAVPacket(buf: pointer<pointer<AVBufferRef>>, size: size) {
+  avbufferRealloc(buf, size + static_cast<size>(AV_INPUT_BUFFER_PADDING_SIZE as uint32))
+  memset(accessof(buf).data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE)
+  return 0
+}
+
+export function refAVPacket(dst: pointer<AVPacket>, src: pointer<AVPacket>) {
+  if (dst.buf) {
+    avbufferUnref(addressof(dst.buf))
+  }
+  dst.buf = nullptr
+  copyAVPacketProps(dst, src)
+
+  if (!src.buf && src.size) {
+    allocAVPacket(addressof(dst.buf), reinterpret_cast<size>(src.size))
+    if (src.size) {
+      memcpy(dst.buf.data, src.data, reinterpret_cast<size>(src.size))
+    }
+    dst.data = dst.buf.data
+  }
+  else if (src.buf) {
+    dst.buf = avbufferRef(src.buf)
+    dst.data = src.data
+  }
+  dst.size = src.size
+
+  return 0
+}
+
+export function unrefAVPacket(avpacket: pointer<AVPacket>) {
+  freeAVPacketSideData(addressof(avpacket.sideData), addressof(avpacket.sideDataElems))
+  avbufferUnref(addressof(avpacket.opaqueRef))
+
+  if (avpacket.buf) {
+    avbufferUnref(addressof(avpacket.buf))
+  }
+  else if (avpacket.data) {
+    avFree(avpacket.data)
+  }
+  getAVPacketDefault(avpacket)
+}
+
+export function copyAVPacketData(dst: pointer<AVPacket>, src: pointer<AVPacket>) {
+  if (dst.buf) {
+    avbufferUnref(addressof(dst.buf))
+  }
+  dst.buf = nullptr
+  if (!src.buf && src.size) {
+    allocAVPacket(addressof(dst.buf), reinterpret_cast<size>(src.size))
+    if (src.size) {
+      memcpy(dst.buf.data, src.data, reinterpret_cast<size>(src.size))
+    }
+    dst.data = dst.buf.data
+  }
+  else if (src.buf) {
+    dst.buf = avbufferRef(src.buf)
+    dst.data = src.data
+  }
+  dst.size = src.size
+}
+
+export function addAVPacketData(avpacket: pointer<AVPacket>, data: pointer<uint8>, size: int32) {
+
+  if (avpacket.buf) {
+    avbufferUnref(addressof(avpacket.buf))
+  }
+  else if (avpacket.data) {
+    avFree(avpacket.data)
+  }
+
+  avpacket.buf = avbufferCreate(data, size + AV_INPUT_BUFFER_PADDING_SIZE)
+  avpacket.data = data
+  avpacket.size = size
+}

package/src/util/channel.ts

@@ -0,0 +1,66 @@
+/*
+ * libmedia channel 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 { AVChannelCustom, AVChannelLayout } from '../struct/audiosample'
+import { popCount64 } from './common'
+import { AVChannel, AVChannelOrder } from '../audiosamplefmt'
+import { avFreep, avMallocz } from './mem'
+import * as error from '../error'
+
+import { memset } from '@libmedia/cheap'
+
+export function getChannelLayoutNBChannels(layout: uint64) {
+  return popCount64(layout)
+}
+
+export function unInitChannelLayout(channelLayout: pointer<AVChannelLayout>) {
+  if (channelLayout.order == AVChannelOrder.AV_CHANNEL_ORDER_CUSTOM) {
+    avFreep(addressof(channelLayout.u.map))
+  }
+  memset(channelLayout, 0, sizeof(accessof(channelLayout)))
+}
+
+export function setChannelLayoutFromMask(channelLayout: pointer<AVChannelLayout>, mask: uint64) {
+  if (!mask) {
+    return error.INVALID_ARGUMENT
+  }
+  channelLayout.order = AVChannelOrder.AV_CHANNEL_ORDER_NATIVE
+  channelLayout.nbChannels = popCount64(static_cast<uint64>(mask))
+  channelLayout.u.mask = mask
+  return 0
+}
+
+export function initCustomChannelLayout(channelLayout: pointer<AVChannelLayout>, channels: int32) {
+  if (channels <= 0) {
+    throw new Error('invalid channels')
+  }
+  const map: pointer<AVChannelCustom> = avMallocz(reinterpret_cast<size>(reinterpret_cast<size>(channels) * sizeof(accessof(channelLayout.u.map))))
+  for (let i = 0; i < channels; i++) {
+    map[i].id = AVChannel.AV_CHANNEL_UNKNOWN
+  }
+  channelLayout.order = AVChannelOrder.AV_CHANNEL_ORDER_CUSTOM
+  channelLayout.nbChannels = channels
+  channelLayout.u.map = map
+}

package/src/util/codecparameters.ts

@@ -0,0 +1,148 @@
+/*
+ * libmedia codecparameters 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 AVCodecParameters from '../struct/avcodecparameters'
+import { avFree, avFreep, avMalloc, avMallocz } from './mem'
+import { unInitChannelLayout } from './channel'
+import { freeAVPacketSideData } from './avpacket'
+import { AVCodecID, AVMediaType } from '../codec'
+import { AVChannelOrder } from '../audiosamplefmt'
+import { AVChromaLocation, AVColorPrimaries, AVColorRange,
+  AVColorSpace, AVColorTransferCharacteristic, AVFieldOrder
+} from '../pixfmt'
+import { NOPTS_VALUE } from '../constant'
+import { AVPacketSideData } from '../struct/avpacket'
+
+export { default as isHdr } from '../function/isHdr'
+export { default as hasAlphaChannel } from '../function/hasAlphaChannel'
+
+import { memset, memcpy } from '@libmedia/cheap'
+
+function copyCodecParametersSideData(
+  pDst: pointer<pointer<AVPacketSideData>>,
+  pnbDst: pointer<int32>,
+  src: pointer<AVPacketSideData>,
+  nbSrc: int32
+) {
+
+  if (!src) {
+    return
+  }
+
+  const dst = reinterpret_cast<pointer<AVPacketSideData>>(avMallocz(nbSrc * reinterpret_cast<int32>(sizeof(AVPacketSideData))))
+
+  for (let i = 0; i < nbSrc; i++) {
+    dst[i].type = src[i].type
+    dst[i].size = src[i].size
+    dst[i].data = avMalloc(src[i].size)
+    memcpy(dst[i].data, src[i].data, src[i].size)
+  }
+
+  accessof(pnbDst) <- nbSrc
+  accessof(pDst) <- dst
+
+  return 0
+}
+
+export function copyCodecParameters(dst: pointer<AVCodecParameters>, src: pointer<AVCodecParameters>) {
+  dst.codecType = src.codecType
+  dst.codecId = src.codecId
+  dst.codecTag = src.codecTag
+  dst.format = src.format
+  dst.bitrate = src.bitrate
+  dst.bitsPerCodedSample = src.bitsPerCodedSample
+  dst.bitsPerRawSample = src.bitsPerRawSample
+  dst.profile = src.profile
+  dst.level = src.level
+  dst.width = src.width
+  dst.height = src.height
+  dst.sampleAspectRatio.den = src.sampleAspectRatio.den
+  dst.sampleAspectRatio.num = src.sampleAspectRatio.num
+  dst.fieldOrder = src.fieldOrder
+  dst.colorRange = src.colorRange
+  dst.colorPrimaries = src.colorPrimaries
+  dst.colorTrc = src.colorTrc
+  dst.colorSpace = src.colorSpace
+  dst.chromaLocation = src.chromaLocation
+  dst.videoDelay = src.videoDelay
+  dst.chLayout = src.chLayout
+  dst.sampleRate = src.sampleRate
+  dst.blockAlign = src.blockAlign
+  dst.frameSize = src.frameSize
+  dst.initialPadding = src.initialPadding
+  dst.trailingPadding = src.trailingPadding
+  dst.seekPreroll = src.seekPreroll
+  dst.flags = src.flags
+
+  dst.framerate = src.framerate
+
+  if (src.extradata) {
+    if (dst.extradata) {
+      avFree(dst.extradata)
+    }
+    dst.extradata = avMalloc(reinterpret_cast<size>(src.extradataSize))
+    dst.extradataSize = src.extradataSize
+    memcpy(dst.extradata, src.extradata, reinterpret_cast<size>(src.extradataSize))
+  }
+
+  if (src.codedSideData) {
+    copyCodecParametersSideData(addressof(dst.codedSideData), addressof(dst.nbCodedSideData), src.codedSideData, src.nbCodedSideData)
+  }
+}
+
+export function resetCodecParameters(par: pointer<AVCodecParameters>) {
+  if (par.extradata) {
+    avFreep(addressof(par.extradata))
+  }
+  unInitChannelLayout(addressof(par.chLayout))
+  freeAVPacketSideData(addressof(par.codedSideData), addressof(par.nbCodedSideData))
+  memset(par, 0, sizeof(accessof(par)))
+
+  par.codecType = AVMediaType.AVMEDIA_TYPE_UNKNOWN
+  par.codecId = AVCodecID.AV_CODEC_ID_NONE
+  par.format = -1
+  par.chLayout.order = AVChannelOrder.AV_CHANNEL_ORDER_UNSPEC
+  par.fieldOrder = AVFieldOrder.AV_FIELD_UNKNOWN
+  par.colorRange = AVColorRange.AVCOL_RANGE_UNSPECIFIED
+  par.colorPrimaries = AVColorPrimaries.AVCOL_PRI_UNSPECIFIED
+  par.colorTrc = AVColorTransferCharacteristic.AVCOL_TRC_UNSPECIFIED
+  par.colorSpace = AVColorSpace.AVCOL_SPC_UNSPECIFIED
+  par.chromaLocation = AVChromaLocation.AVCHROMA_LOC_UNSPECIFIED
+  par.sampleAspectRatio.num = 0
+  par.sampleAspectRatio.den = 1
+  par.framerate.num = 0
+  par.framerate.num = 1
+  par.profile = NOPTS_VALUE
+  par.level = NOPTS_VALUE
+  par.flags = 0
+}
+
+export function freeCodecParameters(par: pointer<AVCodecParameters>) {
+  if (!par) {
+    return
+  }
+  resetCodecParameters(par)
+  avFree(par)
+}

package/src/util/common.ts

@@ -0,0 +1,42 @@
+/*
+ * libmedia common 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 popCount(x: uint32) {
+  x -= (x >> 1) & 0x55555555
+  x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
+  x = (x + (x >> 4)) & 0x0F0F0F0F
+  x += x >> 8
+  return (x + (x >> 16)) & 0x3F
+}
+
+export function popCount64(x: uint64) {
+  return popCount(static_cast<uint32>(x)) + popCount(static_cast<uint32>(x >> 32n))
+}
+
+export function milliSecond2Second(time: int64) {
+  const integer = time / 1000n
+  const decimal = time - integer * 1000n
+  return Number(integer) + Number(decimal) / 1000
+}