bare-media 1.8.0 → 2.1.0

package/shared/spec/schema.js

@@ -1,212 +0,0 @@
-import Hyperschema from 'hyperschema'
-
-import { SCHEMA_DIR } from './constants'
-
-export const schema = Hyperschema.from(SCHEMA_DIR)
-const media = schema.namespace('media')
-
-media.register({
-  name: 'dimensions',
-  fields: [
-    {
-      name: 'width',
-      type: 'uint',
-      required: true
-    },
-    {
-      name: 'height',
-      type: 'uint',
-      required: true
-    }
-  ]
-})
-
-media.register({
-  name: 'metadata',
-  fields: [
-    {
-      name: 'mimetype',
-      type: 'string'
-    },
-    {
-      name: 'dimensions',
-      type: '@media/dimensions'
-    },
-    {
-      name: 'duration',
-      type: 'uint'
-    }
-  ]
-})
-
-media.register({
-  name: 'file',
-  fields: [
-    {
-      name: 'metadata',
-      type: '@media/metadata'
-    },
-    {
-      name: 'inlined',
-      type: 'string'
-    },
-    {
-      name: 'buffer',
-      type: 'buffer'
-    }
-  ]
-})
-
-media.register({
-  name: 'create-preview-request',
-  fields: [
-    {
-      name: 'path',
-      type: 'string'
-    },
-    {
-      name: 'httpLink',
-      type: 'string'
-    },
-    {
-      name: 'buffer',
-      type: 'buffer'
-    },
-    {
-      name: 'mimetype',
-      type: 'string'
-    },
-    {
-      name: 'maxWidth',
-      type: 'uint'
-    },
-    {
-      name: 'maxHeight',
-      type: 'uint'
-    },
-    {
-      name: 'maxFrames',
-      type: 'uint'
-    },
-    {
-      name: 'maxBytes',
-      type: 'uint'
-    },
-    {
-      name: 'format',
-      type: 'string'
-    },
-    {
-      name: 'encoding',
-      type: 'string'
-    }
-  ]
-})
-
-media.register({
-  name: 'create-preview-response',
-  fields: [
-    {
-      name: 'metadata',
-      type: '@media/metadata',
-      required: true
-    },
-    {
-      name: 'preview',
-      type: '@media/file',
-      required: true
-    }
-  ]
-})
-
-media.register({
-  name: 'decode-image-request',
-  fields: [
-    {
-      name: 'path',
-      type: 'string'
-    },
-    {
-      name: 'httpLink',
-      type: 'string'
-    },
-    {
-      name: 'buffer',
-      type: 'buffer'
-    },
-    {
-      name: 'mimetype',
-      type: 'string'
-    }
-  ]
-})
-
-media.register({
-  name: 'decode-image-response',
-  fields: [
-    {
-      name: 'metadata',
-      type: '@media/metadata'
-    },
-    {
-      name: 'data',
-      type: 'buffer'
-    }
-  ]
-})
-
-media.register({
-  name: 'crop-image-request',
-  fields: [
-    {
-      name: 'path',
-      type: 'string'
-    },
-    {
-      name: 'httpLink',
-      type: 'string'
-    },
-    {
-      name: 'buffer',
-      type: 'buffer'
-    },
-    {
-      name: 'mimetype',
-      type: 'string'
-    },
-    {
-      name: 'left',
-      type: 'uint'
-    },
-    {
-      name: 'top',
-      type: 'uint'
-    },
-    {
-      name: 'width',
-      type: 'uint'
-    },
-    {
-      name: 'height',
-      type: 'uint'
-    },
-    {
-      name: 'format',
-      type: 'string'
-    }
-  ]
-})
-
-media.register({
-  name: 'crop-image-response',
-  fields: [
-    {
-      name: 'metadata',
-      type: '@media/metadata'
-    },
-    {
-      name: 'data',
-      type: 'buffer'
-    }
-  ]
-})

package/worker/index.js

@@ -1,25 +0,0 @@
-import worker from 'cross-worker'
-import uncaughts from 'uncaughts'
-
-import HRPC from '../shared/spec/hrpc'
-
-import * as media from './media'
-import { log } from './util'
-
-log('Worker started 🚀')
-
-const stream = worker.stream()
-
-stream.on('end', () => stream.end())
-stream.on('error', (err) => console.error(err))
-stream.on('close', () => Bare.exit(0))
-
-const rpc = new HRPC(stream)
-
-rpc.onCreatePreview(media.createPreview)
-rpc.onDecodeImage(media.decodeImage)
-rpc.onCropImage(media.cropImage)
-
-uncaughts.on((err) => {
-  log('Uncaught error:', err)
-})

package/worker/media.js

@@ -1,274 +0,0 @@
-import b4a from 'b4a'
-
-import {
-  importCodec,
-  isCodecSupported,
-  supportsQuality
-} from '../shared/codecs.js'
-import { getBuffer, detectMimeType, calculateFitDimensions } from './util'
-
-const DEFAULT_PREVIEW_FORMAT = 'image/webp'
-
-const animatableMimetypes = ['image/webp']
-
-export async function createPreview({
-  path,
-  httpLink,
-  buffer,
-  mimetype,
-  maxWidth,
-  maxHeight,
-  maxFrames,
-  maxBytes,
-  format,
-  encoding
-}) {
-  format = format || DEFAULT_PREVIEW_FORMAT
-
-  const buff = await getBuffer({ path, httpLink, buffer })
-  mimetype = mimetype || detectMimeType(buff, path)
-
-  if (!isCodecSupported(mimetype)) {
-    throw new Error(`Unsupported file type: No codec available for ${mimetype}`)
-  }
-
-  const rgba = await decodeImageToRGBA(buff, mimetype, maxFrames)
-  const { width, height } = rgba
-
-  const maybeResizedRGBA = await resizeRGBA(rgba, maxWidth, maxHeight)
-
-  let preview = await encodeImageFromRGBA(maybeResizedRGBA, format)
-
-  // quality reduction
-
-  if (maxBytes && preview.byteLength > maxBytes && supportsQuality(format)) {
-    const MIN_QUALITY = 50
-    for (let quality = 80; quality >= MIN_QUALITY; quality -= 15) {
-      preview = await encodeImageFromRGBA(maybeResizedRGBA, format, { quality })
-      if (preview.byteLength <= maxBytes) {
-        break
-      }
-    }
-  }
-
-  // fps reduction
-
-  if (
-    maxBytes &&
-    preview.byteLength > maxBytes &&
-    maybeResizedRGBA.frames?.length > 1
-  ) {
-    const quality = 75
-
-    // drop every n frame
-
-    for (const dropEvery of [4, 3, 2]) {
-      const frames = maybeResizedRGBA.frames.filter(
-        (frame, index) => index % dropEvery !== 0
-      )
-      const filtered = { ...maybeResizedRGBA, frames }
-      preview = await encodeImageFromRGBA(filtered, format, { quality })
-      if (!maxBytes || preview.byteLength <= maxBytes) {
-        break
-      }
-    }
-
-    // cap to 25 frames
-
-    if (preview.byteLength > maxBytes) {
-      const frames = maybeResizedRGBA.frames
-        .slice(0, 50)
-        .filter((frame, index) => index % 2 === 0)
-      const capped = { ...maybeResizedRGBA, frames }
-      preview = await encodeImageFromRGBA(capped, format, { quality })
-    }
-
-    // take only one frame
-
-    if (preview.byteLength > maxBytes) {
-      const oneFrame = {
-        ...maybeResizedRGBA,
-        frames: maybeResizedRGBA.frames.slice(0, 1)
-      }
-      preview = await encodeImageFromRGBA(oneFrame, format)
-    }
-  }
-
-  if (maxBytes && preview.byteLength > maxBytes) {
-    throw new Error(
-      `Could not create preview under maxBytes, reached ${preview.byteLength} bytes`
-    )
-  }
-
-  const encoded =
-    encoding === 'base64'
-      ? { inlined: b4a.toString(preview, 'base64') }
-      : { buffer: preview }
-
-  return {
-    metadata: {
-      dimensions: { width, height }
-    },
-    preview: {
-      metadata: {
-        mimetype: format,
-        dimensions: {
-          width: maybeResizedRGBA.width,
-          height: maybeResizedRGBA.height
-        }
-      },
-      ...encoded
-    }
-  }
-}
-
-export async function decodeImage({ path, httpLink, buffer, mimetype }) {
-  const buff = await getBuffer({ path, httpLink, buffer })
-  mimetype = mimetype || detectMimeType(buff, path)
-
-  if (!isCodecSupported(mimetype)) {
-    throw new Error(`Unsupported file type: No codec available for ${mimetype}`)
-  }
-
-  const rgba = await decodeImageToRGBA(buff, mimetype)
-  const { width, height, data } = rgba
-
-  return {
-    metadata: {
-      dimensions: { width, height }
-    },
-    data
-  }
-}
-
-export async function cropImage({
-  path,
-  httpLink,
-  buffer,
-  mimetype,
-  left,
-  top,
-  width,
-  height,
-  format
-}) {
-  const buff = await getBuffer({ path, httpLink, buffer })
-  mimetype = mimetype || detectMimeType(buff, path)
-
-  if (!isCodecSupported(mimetype)) {
-    throw new Error(`Unsupported file type: No codec available for ${mimetype}`)
-  }
-
-  const rgba = await decodeImageToRGBA(buff, mimetype)
-
-  const cropped = await cropRGBA(rgba, left, top, width, height)
-
-  const data = await encodeImageFromRGBA(cropped, format || mimetype)
-
-  return {
-    metadata: {
-      dimensions: {
-        width: rgba.width,
-        height: rgba.height
-      }
-    },
-    data
-  }
-}
-
-async function decodeImageToRGBA(buffer, mimetype, maxFrames) {
-  let rgba
-
-  const codec = await importCodec(mimetype)
-
-  if (animatableMimetypes.includes(mimetype)) {
-    const { width, height, loops, frames } = codec.decodeAnimated(buffer)
-    const data = []
-    for (const frame of frames) {
-      if (maxFrames > 0 && data.length >= maxFrames) break
-      data.push(frame)
-    }
-    rgba = { width, height, loops, frames: data }
-  } else {
-    rgba = codec.decode(buffer)
-  }
-
-  return rgba
-}
-
-async function encodeImageFromRGBA(rgba, format, opts) {
-  const codec = await importCodec(format)
-
-  let encoded
-  if (Array.isArray(rgba.frames)) {
-    encoded = codec.encodeAnimated(rgba, opts)
-  } else {
-    encoded = codec.encode(rgba, opts)
-  }
-
-  return encoded
-}
-
-async function resizeRGBA(rgba, maxWidth, maxHeight) {
-  const { width, height } = rgba
-
-  let maybeResizedRGBA
-
-  if (maxWidth && maxHeight && (width > maxWidth || height > maxHeight)) {
-    const { resize } = await import('bare-image-resample')
-    const dimensions = calculateFitDimensions(
-      width,
-      height,
-      maxWidth,
-      maxHeight
-    )
-    if (Array.isArray(rgba.frames)) {
-      const frames = []
-      for (const frame of rgba.frames) {
-        const resized = resize(frame, dimensions.width, dimensions.height)
-        frames.push({ ...resized, timestamp: frame.timestamp })
-      }
-      maybeResizedRGBA = {
-        width: frames[0].width,
-        height: frames[0].height,
-        loops: rgba.loops,
-        frames
-      }
-    } else {
-      maybeResizedRGBA = resize(rgba, dimensions.width, dimensions.height)
-    }
-  } else {
-    maybeResizedRGBA = rgba
-  }
-
-  return maybeResizedRGBA
-}
-
-async function cropRGBA(rgba, left, top, width, height) {
-  if (
-    left < 0 ||
-    top < 0 ||
-    width <= 0 ||
-    height <= 0 ||
-    left + width > rgba.width ||
-    top + height > rgba.height
-  ) {
-    throw new Error('Crop rectangle out of bounds')
-  }
-
-  const data = Buffer.alloc(width * height * 4)
-
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const srcIndex = ((y + top) * rgba.width + (x + left)) * 4
-      const dstIndex = (y * width + x) * 4
-
-      data[dstIndex] = rgba.data[srcIndex]
-      data[dstIndex + 1] = rgba.data[srcIndex + 1]
-      data[dstIndex + 2] = rgba.data[srcIndex + 2]
-      data[dstIndex + 3] = rgba.data[srcIndex + 3]
-    }
-  }
-
-  return { width, height, data }
-}

package/worker/util.js

@@ -1,42 +0,0 @@
-import fs from 'bare-fs'
-import fetch from 'bare-fetch'
-import getMimeType from 'get-mime-type'
-import getFileFormat from 'get-file-format'
-
-export const log = (...args) => console.log('[bare-media]', ...args)
-
-export async function getBuffer({ path, httpLink, buffer }) {
-  if (buffer) return buffer
-
-  if (path) {
-    return fs.readFileSync(path)
-  }
-
-  if (httpLink) {
-    const response = await fetch(httpLink)
-    return await response.buffer()
-  }
-
-  throw new Error(
-    'At least one of "path", "httpLink" or "buffer" must be provided'
-  )
-}
-
-export function detectMimeType(buffer, path) {
-  return getMimeType(getFileFormat(buffer)) || getMimeType(path)
-}
-
-export function calculateFitDimensions(width, height, maxWidth, maxHeight) {
-  if (width <= maxWidth && height <= maxHeight) {
-    return { width, height }
-  }
-
-  const widthRatio = maxWidth / width
-  const heightRatio = maxHeight / height
-  const ratio = Math.min(widthRatio, heightRatio)
-
-  return {
-    width: Math.round(width * ratio),
-    height: Math.round(height * ratio)
-  }
-}