bare-media 2.1.0 → 2.3.0-0

package/README.md

@@ -115,9 +115,34 @@ Extracts frames from a video in RGBA
 
 | Parameter         | Type   | Description                    |
 | ----------------- | ------ | ------------------------------ |
-| `fd`              | number | File descriptor                |
 | `opts.frameIndex` | number | Number of the frame to extract |
 
+### transcode()
+
+Transcode a media file to a different format
+
+| Parameter     | Type   | Description                                                         |
+| ------------- | ------ | ------------------------------------------------------------------- |
+| `opts.format` | string | Output format name (e.g., `mp4`, `webm`, `matroska`). Default `mp4` |
+| `opts.width`  | number | Width of the output video                                           |
+| `opts.height` | number | Height of the output video                                          |
+
+**Supported formats**: `mp4` (VP9+Opus), `webm` (VP8+Opus), `matroska`/`mkv` (VP9+Opus)
+
+#### Example
+
+```javascript
+import { video } from 'bare-media'
+
+for await (const chunk of video('input.mkv').transcode({
+  format: 'mp4',
+  width: 1280,
+  height: 720
+})) {
+  console.log('Received chunk:', chunk.buffer.length)
+}
+```
+
 ## Supported Types
 
 Helpers to check supported media types are exposed in `bare-media/types`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-media",
-  "version": "2.1.0",
+  "version": "2.3.0-0",
   "description": "A set of media APIs for Bare",
   "main": "index.js",
   "type": "module",
@@ -17,7 +17,8 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "npm run format:check && lunte",
-    "test": "brittle-bare test/index.js"
+    "test": "brittle-bare test/index.js",
+    "example": "bare examples/index.js"
   },
   "keywords": [],
   "author": "Holepunch Inc",
@@ -33,7 +34,7 @@
   "dependencies": {
     "bare-bmp": "^1.0.0",
     "bare-fetch": "^2.4.1",
-    "bare-ffmpeg": "^1.0.0",
+    "bare-ffmpeg": "^1.1.0",
     "bare-fs": "^4.1.5",
     "bare-gif": "^1.1.2",
     "bare-heif": "^1.0.5",
@@ -41,14 +42,17 @@
     "bare-image-resample": "^1.0.1",
     "bare-jpeg": "^1.0.1",
     "bare-png": "^1.0.2",
+    "bare-svg": "^1.0.1",
     "bare-tiff": "^1.0.1",
     "bare-webp": "^1.0.3",
-    "get-file-format": "^1.0.1",
+    "get-file-format": "^1.1.0",
     "get-mime-type": "^2.0.1"
   },
   "devDependencies": {
     "b4a": "^1.7.3",
     "bare-os": "^3.6.2",
+    "bare-path": "^3.0.0",
+    "bare-process": "^4.2.2",
     "brittle": "^3.16.3",
     "corestore": "^7.4.5",
     "hyperblobs": "^2.8.0",

package/src/codecs.js

@@ -9,6 +9,7 @@ export const codecs = {
   [IMAGE.JPEG]: () => import('bare-jpeg'),
   [IMAGE.JPG]: () => import('bare-jpeg'),
   [IMAGE.PNG]: () => import('bare-png'),
+  [IMAGE.SVG_XML]: () => import('bare-svg'),
   [IMAGE.TIF]: () => import('bare-tiff'),
   [IMAGE.TIFF]: () => import('bare-tiff'),
   [IMAGE.VND_MS_ICON]: () => import('bare-ico'),

package/src/{video.js → video/index.js}

@@ -1,5 +1,6 @@
 import fs from 'bare-fs'
 import ffmpeg from 'bare-ffmpeg'
+import { Transcoder } from './transcoder.js'
 
 function extractFrames(fd, opts = {}) {
   const { frameIndex } = opts
@@ -89,6 +90,18 @@ function extractFrames(fd, opts = {}) {
   return result
 }
 
+async function* transcode(fd, opts = {}) {
+  const transcoder = new Transcoder(fd, {
+    outputParameters: {
+      format: opts.format,
+      width: opts.width,
+      height: opts.height
+    },
+    bufferSize: opts.bufferSize
+  })
+  yield* transcoder.transcode()
+}
+
 class VideoPipeline {
   constructor(input) {
     this.input = input
@@ -101,6 +114,15 @@ class VideoPipeline {
     fs.closeSync(fd)
     return result
   }
+
+  async *transcode(opts) {
+    const fd = fs.openSync(this.input, 'r')
+    try {
+      yield* transcode(fd, opts)
+    } finally {
+      fs.closeSync(fd)
+    }
+  }
 }
 
 function video(input) {
@@ -108,5 +130,6 @@ function video(input) {
 }
 
 video.extractFrames = extractFrames
+video.transcode = transcode
 
 export { video }

package/src/video/transcoder.js

@@ -0,0 +1,538 @@
+import fs from 'bare-fs'
+import b4a from 'b4a'
+import ffmpeg from 'bare-ffmpeg'
+
+const { VIDEO, AUDIO } = ffmpeg.constants.mediaTypes
+
+class FormatRegistry {
+  #formats = new Map()
+
+  register(formatName, config) {
+    this.#formats.set(formatName, {
+      video: config.video,
+      audio: config.audio,
+      muxer: config.muxer || {}
+    })
+  }
+
+  getVideoConfig(formatName) {
+    const format = this.#formats.get(formatName)
+    if (!format?.video) {
+      throw new Error(`Unsupported video output format: ${formatName}`)
+    }
+    return format.video
+  }
+
+  getAudioConfig(formatName) {
+    const format = this.#formats.get(formatName)
+    if (!format?.audio) {
+      throw new Error(`Unsupported audio output format: ${formatName}`)
+    }
+    return format.audio
+  }
+
+  getMuxerOptions(formatName) {
+    const format = this.#formats.get(formatName)
+    return format?.muxer || {}
+  }
+
+  hasFormat(formatName) {
+    return this.#formats.has(formatName)
+  }
+}
+
+const formatRegistry = new FormatRegistry()
+
+formatRegistry.register('webm', {
+  video: {
+    id: ffmpeg.constants.codecs.VP8,
+    format: ffmpeg.constants.pixelFormats.YUV420P,
+    encoder: 'libvpx'
+  },
+  audio: {
+    id: ffmpeg.constants.codecs.OPUS,
+    format: ffmpeg.constants.sampleFormats.FLTP,
+    sampleRate: 48000,
+    encoder: 'libopus'
+  },
+  muxer: { live: '1' }
+})
+
+formatRegistry.register('mp4', {
+  video: {
+    id: ffmpeg.constants.codecs.VP9,
+    format: ffmpeg.constants.pixelFormats.YUV420P,
+    encoder: 'libvpx-vp9'
+  },
+  audio: {
+    id: ffmpeg.constants.codecs.OPUS,
+    format: ffmpeg.constants.sampleFormats.FLTP,
+    sampleRate: 48000,
+    encoder: 'libopus'
+  },
+  muxer: { movflags: 'frag_keyframe+empty_moov+default_base_moof' }
+})
+
+formatRegistry.register('matroska', {
+  video: {
+    id: ffmpeg.constants.codecs.VP9,
+    format: ffmpeg.constants.pixelFormats.YUV420P,
+    encoder: 'libvpx-vp9'
+  },
+  audio: {
+    id: ffmpeg.constants.codecs.OPUS,
+    format: ffmpeg.constants.sampleFormats.FLTP,
+    sampleRate: 48000,
+    encoder: 'libopus'
+  },
+  muxer: { live: '1' }
+})
+
+formatRegistry.register('mkv', {
+  video: {
+    id: ffmpeg.constants.codecs.VP9,
+    format: ffmpeg.constants.pixelFormats.YUV420P,
+    encoder: 'libvpx-vp9'
+  },
+  audio: {
+    id: ffmpeg.constants.codecs.OPUS,
+    format: ffmpeg.constants.sampleFormats.FLTP,
+    sampleRate: 48000,
+    encoder: 'libopus'
+  },
+  muxer: { live: '1' }
+})
+
+class TranscodeStreamConfig {
+  static create(inputStream, outputFormatContext, containerFormat, outputParameters) {
+    const config = new TranscodeStreamConfig(
+      inputStream,
+      outputFormatContext,
+      containerFormat,
+      outputParameters
+    )
+    return config.#initialize() ? config : null
+  }
+
+  constructor(inputStream, outputFormatContext, containerFormat, outputParameters) {
+    this.inputStream = inputStream
+    this.outputFormatContext = outputFormatContext
+    this.containerFormat = containerFormat
+    this.outputParameters = outputParameters
+    this.codecType = inputStream.codecParameters.type
+
+    this.outputStream = null
+    this.decoder = null
+    this.encoder = null
+    this.rescaler = null
+    this.resampler = null
+    this.fifo = null
+    this.fifoFrame = null
+    this.samplesWritten = 0
+    this.nextVideoPts = 0
+    this.lastWidth = null
+    this.lastHeight = null
+    this.lastFormat = null
+  }
+
+  isVideo() {
+    return this.codecType === VIDEO
+  }
+
+  isAudio() {
+    return this.codecType === AUDIO
+  }
+
+  getConfig() {
+    return this.isVideo()
+      ? formatRegistry.getVideoConfig(this.containerFormat)
+      : formatRegistry.getAudioConfig(this.containerFormat)
+  }
+
+  #initialize() {
+    this.decoder = this.#createDecoder()
+    if (!this.decoder) return false
+
+    this.outputStream = this.outputFormatContext.createStream()
+    this.#configureOutputStream(this.outputStream, this.decoder)
+
+    this.encoder = this.#createEncoder(this.outputStream, this.decoder)
+    this.outputStream.codecParameters.fromContext(this.encoder)
+
+    return true
+  }
+
+  #createDecoder() {
+    const decoderContext = this.inputStream.decoder()
+    try {
+      decoderContext.open()
+      return decoderContext
+    } catch (err) {
+      console.warn(`Failed to open decoder for stream ${this.inputStream.index}: ${err.message}`)
+      decoderContext.destroy()
+      return null
+    }
+  }
+
+  #configureOutputStream(outputStream, decoder) {
+    const config = this.getConfig()
+
+    outputStream.codecParameters.type = this.codecType
+    outputStream.codecParameters.id = config.id
+    outputStream.codecParameters.format = config.format
+
+    if (this.isVideo()) {
+      outputStream.codecParameters.width = this.outputParameters?.width || decoder.width
+      outputStream.codecParameters.height = this.outputParameters?.height || decoder.height
+      outputStream.timeBase = new ffmpeg.Rational(1, 90000)
+    } else {
+      outputStream.codecParameters.sampleRate = config.sampleRate
+      outputStream.codecParameters.channelLayout = decoder.channelLayout
+      outputStream.timeBase = new ffmpeg.Rational(1, config.sampleRate)
+    }
+  }
+
+  #createEncoder(outputStream, decoder) {
+    const config = this.getConfig()
+    const encoder = new ffmpeg.CodecContext(new ffmpeg.Encoder(config.encoder))
+    outputStream.codecParameters.toContext(encoder)
+
+    if (this.isVideo()) {
+      this.#configureVideoEncoder(encoder, outputStream, decoder)
+    } else {
+      this.#configureAudioEncoder(encoder, outputStream)
+    }
+
+    if (this.outputFormatContext.outputFormat.flags & ffmpeg.constants.formatFlags.GLOBALHEADER) {
+      encoder.flags |= ffmpeg.constants.codecFlags.GLOBAL_HEADER
+    }
+
+    const encoderOptions = this.isVideo()
+      ? ffmpeg.Dictionary.from({ allow_sw: '1' })
+      : new ffmpeg.Dictionary()
+
+    encoder.open(encoderOptions)
+    return encoder
+  }
+
+  #configureVideoEncoder(encoder, outputStream, decoder) {
+    encoder.timeBase = outputStream.timeBase
+    encoder.width = outputStream.codecParameters.width
+    encoder.height = outputStream.codecParameters.height
+    encoder.pixelFormat = outputStream.codecParameters.format
+
+    if (decoder.frameRate && decoder.frameRate.valid) {
+      encoder.frameRate = decoder.frameRate
+    } else {
+      encoder.frameRate = new ffmpeg.Rational(30, 1)
+    }
+    encoder.gopSize = 30
+  }
+
+  #configureAudioEncoder(encoder, outputStream) {
+    encoder.timeBase = outputStream.timeBase
+    encoder.sampleRate = outputStream.codecParameters.sampleRate
+    encoder.channelLayout = outputStream.codecParameters.channelLayout
+    encoder.sampleFormat = outputStream.codecParameters.format
+  }
+}
+
+class VideoFrameProcessor {
+  constructor(transcoder) {
+    this.transcoder = transcoder
+  }
+
+  process(frame, config, packet) {
+    const { encoder, outputStream } = config
+
+    if (
+      !config.rescaler ||
+      config.lastWidth !== frame.width ||
+      config.lastHeight !== frame.height ||
+      config.lastFormat !== frame.format
+    ) {
+      if (config.rescaler) config.rescaler.destroy()
+
+      config.rescaler = new ffmpeg.Scaler(
+        frame.format,
+        frame.width,
+        frame.height,
+        encoder.pixelFormat,
+        encoder.width,
+        encoder.height
+      )
+
+      config.lastWidth = frame.width
+      config.lastHeight = frame.height
+      config.lastFormat = frame.format
+    }
+
+    const outFrame = new ffmpeg.Frame()
+    outFrame.format = encoder.pixelFormat
+    outFrame.width = encoder.width
+    outFrame.height = encoder.height
+    outFrame.alloc()
+    outFrame.copyProperties(frame)
+
+    config.rescaler.scale(frame, outFrame)
+
+    outFrame.pts = config.nextVideoPts
+    const frameDuration =
+      (encoder.timeBase.denominator * encoder.frameRate.denominator) /
+      (encoder.timeBase.numerator * encoder.frameRate.numerator)
+    config.nextVideoPts += frameDuration
+
+    this.transcoder._encodeAndWrite(encoder, outFrame, outputStream, packet)
+
+    outFrame.destroy()
+  }
+}
+
+class AudioFrameProcessor {
+  constructor(transcoder) {
+    this.transcoder = transcoder
+  }
+
+  process(frame, config, packet) {
+    const { encoder, outputStream } = config
+
+    if (!config.resampler) {
+      config.resampler = new ffmpeg.Resampler(
+        frame.sampleRate,
+        frame.channelLayout,
+        frame.format,
+        encoder.sampleRate,
+        encoder.channelLayout,
+        encoder.sampleFormat
+      )
+    }
+
+    if (!config.fifo) {
+      config.fifo = new ffmpeg.AudioFIFO(
+        encoder.sampleFormat,
+        encoder.channelLayout.nbChannels,
+        encoder.frameSize
+      )
+      config.fifoFrame = new ffmpeg.Frame()
+      config.fifoFrame.format = encoder.sampleFormat
+      config.fifoFrame.channelLayout = encoder.channelLayout
+      config.fifoFrame.sampleRate = encoder.sampleRate
+    }
+
+    const outFrame = new ffmpeg.Frame()
+    outFrame.format = encoder.sampleFormat
+    outFrame.channelLayout = encoder.channelLayout
+    outFrame.sampleRate = encoder.sampleRate
+
+    const outSamples = Math.ceil((frame.nbSamples * encoder.sampleRate) / frame.sampleRate) + 32
+    outFrame.nbSamples = outSamples
+    outFrame.alloc()
+
+    const convertedSamples = config.resampler.convert(frame, outFrame)
+    outFrame.nbSamples = convertedSamples
+
+    config.fifo.write(outFrame)
+    outFrame.destroy()
+
+    const frameSize = encoder.frameSize
+    while (config.fifo.size >= frameSize) {
+      config.fifoFrame.nbSamples = frameSize
+      config.fifoFrame.alloc()
+
+      config.fifo.read(config.fifoFrame, frameSize)
+
+      config.fifoFrame.pts = config.samplesWritten
+      config.samplesWritten += config.fifoFrame.nbSamples
+
+      this.transcoder._encodeAndWrite(encoder, config.fifoFrame, outputStream, packet)
+    }
+  }
+
+  flush(config, packet) {
+    if (config.fifo && config.fifo.size > 0) {
+      const remaining = config.fifo.size
+      config.fifoFrame.nbSamples = remaining
+      config.fifoFrame.alloc()
+      config.fifo.read(config.fifoFrame, remaining)
+      config.fifoFrame.pts = config.samplesWritten
+      config.samplesWritten += config.fifoFrame.nbSamples
+      this.transcoder._encodeAndWrite(config.encoder, config.fifoFrame, config.outputStream, packet)
+    }
+  }
+}
+
+class Transcoder {
+  constructor(fd, opts = {}) {
+    this.fd = fd
+    this.outputParameters = opts.outputParameters || {}
+    this.bufferSize = opts.bufferSize || 32 * 1024
+
+    this.chunks = []
+    this.inputFormatContext = null
+    this.outputFormatContext = null
+    this.configs = []
+    this.containerFormat = null
+
+    this.videoProcessor = new VideoFrameProcessor(this)
+    this.audioProcessor = new AudioFrameProcessor(this)
+  }
+
+  async *transcode() {
+    try {
+      this.#setupIOContexts()
+      this.#discoverAndConfigureStreams()
+      this.#configureOutput()
+      this.#processFrames()
+      this.#finalize()
+    } finally {
+      this.#cleanup()
+    }
+
+    for (const chunk of this.chunks) {
+      yield { buffer: chunk }
+    }
+  }
+
+  #setupIOContexts() {
+    const fileSize = fs.fstatSync(this.fd).size
+    let offset = 0
+
+    const inIO = new ffmpeg.IOContext(4096, {
+      onread: (buffer, requested) => {
+        const read = fs.readSync(this.fd, buffer, 0, requested, offset)
+        if (read === 0) return 0
+        offset += read
+        return read
+      },
+      onseek: (o, whence) => {
+        if (whence === ffmpeg.constants.seek.SIZE) return fileSize
+        if (whence === ffmpeg.constants.seek.SET) offset = o
+        else if (whence === ffmpeg.constants.seek.CUR) offset += o
+        else if (whence === ffmpeg.constants.seek.END) offset = fileSize + o
+        else return -1
+        return offset
+      }
+    })
+
+    this.inputFormatContext = new ffmpeg.InputFormatContext(inIO)
+
+    const outIO = new ffmpeg.IOContext(this.bufferSize, {
+      onwrite: (chunk) => {
+        this.chunks.push(b4a.from(chunk))
+        return chunk.length
+      }
+    })
+
+    this.containerFormat = this.outputParameters?.format || 'mp4'
+
+    if (!formatRegistry.hasFormat(this.containerFormat)) {
+      throw new Error(`Unsupported output format: ${this.containerFormat}`)
+    }
+
+    this.outputFormatContext = new ffmpeg.OutputFormatContext(this.containerFormat, outIO)
+  }
+
+  #discoverAndConfigureStreams() {
+    for (const inputStream of this.inputFormatContext.streams) {
+      const codecType = inputStream.codecParameters.type
+
+      if (codecType !== VIDEO && codecType !== AUDIO) {
+        continue
+      }
+
+      const config = TranscodeStreamConfig.create(
+        inputStream,
+        this.outputFormatContext,
+        this.containerFormat,
+        this.outputParameters
+      )
+
+      if (config) {
+        this.configs[inputStream.index] = config
+      }
+    }
+  }
+
+  #configureOutput() {
+    const options = formatRegistry.getMuxerOptions(this.containerFormat)
+    const muxerOptions = ffmpeg.Dictionary.from(options)
+
+    this.outputFormatContext.writeHeader(muxerOptions)
+  }
+
+  #processFrames() {
+    const packet = new ffmpeg.Packet()
+    const frame = new ffmpeg.Frame()
+
+    try {
+      while (this.inputFormatContext.readFrame(packet)) {
+        const config = this.configs[packet.streamIndex]
+        if (!config) {
+          packet.unref()
+          continue
+        }
+
+        const { decoder } = config
+
+        if (decoder.sendPacket(packet)) {
+          while (decoder.receiveFrame(frame)) {
+            if (config.isVideo()) {
+              this.videoProcessor.process(frame, config, packet)
+            } else if (config.isAudio()) {
+              this.audioProcessor.process(frame, config, packet)
+            }
+          }
+        }
+        packet.unref()
+      }
+    } finally {
+      packet.destroy()
+      frame.destroy()
+    }
+  }
+
+  #finalize() {
+    const packet = new ffmpeg.Packet()
+
+    try {
+      for (const index in this.configs) {
+        const config = this.configs[index]
+        this.audioProcessor.flush(config, packet)
+
+        this._encodeAndWrite(config.encoder, null, config.outputStream, packet)
+      }
+
+      this.outputFormatContext.writeTrailer()
+    } finally {
+      packet.destroy()
+    }
+  }
+
+  #cleanup() {
+    for (const index in this.configs) {
+      const config = this.configs[index]
+      config.decoder.destroy()
+      config.encoder.destroy()
+      if (config.rescaler) config.rescaler.destroy()
+      if (config.resampler) config.resampler.destroy()
+      if (config.fifo) config.fifo.destroy()
+      if (config.fifoFrame) config.fifoFrame.destroy()
+    }
+
+    if (this.inputFormatContext) this.inputFormatContext.destroy()
+    if (this.outputFormatContext) this.outputFormatContext.destroy()
+  }
+
+  _encodeAndWrite(encoder, frame, outputStream, packet) {
+    if (encoder.sendFrame(frame)) {
+      while (encoder.receivePacket(packet)) {
+        packet.streamIndex = outputStream.index
+        packet.rescaleTimestamps(encoder.timeBase, outputStream.timeBase)
+        this.outputFormatContext.writeFrame(packet)
+        packet.unref()
+      }
+    }
+  }
+}
+
+export { Transcoder }

package/types.js

@@ -7,6 +7,7 @@ export const IMAGE = {
   JPEG: 'image/jpeg',
   JPG: 'image/jpg',
   PNG: 'image/png',
+  SVG_XML: 'image/svg+xml',
   TIF: 'image/tif',
   TIFF: 'image/tiff',
   VND_MS_ICON: 'image/vnd.microsoft.icon',