bare-media 1.0.0

package/shared/spec/schema.js

@@ -0,0 +1,196 @@
+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: 'preview-by-size',
+  fields: [{
+    name: 'small',
+    type: '@media/file'
+  },
+  {
+    name: 'medium',
+    type: '@media/file'
+  },
+  {
+    name: 'large',
+    type: '@media/file'
+  }]
+})
+
+media.register({
+  name: 'sizePreview',
+  fields: [{
+    name: 'small',
+    type: 'uint',
+    required: true
+  },
+  {
+    name: 'medium',
+    type: 'uint',
+    required: true
+  },
+  {
+    name: 'large',
+    type: 'uint',
+    required: true
+  }]
+})
+
+media.register({
+  name: 'create-preview-request',
+  fields: [{
+    name: 'path',
+    type: 'string',
+    required: true
+  },
+  {
+    name: 'mimetype',
+    type: 'string'
+  },
+  {
+    name: 'maxWidth',
+    type: 'uint'
+  },
+  {
+    name: 'maxHeight',
+    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: 'create-preview-all-request',
+  fields: [{
+    name: 'path',
+    type: 'string',
+    required: true
+  },
+  {
+    name: 'mimetype',
+    type: 'string'
+  },
+  {
+    name: 'maxWidth',
+    type: '@media/sizePreview',
+    required: true
+  },
+  {
+    name: 'maxHeight',
+    type: '@media/sizePreview',
+    required: true
+  },
+  {
+    name: 'format',
+    type: 'string'
+  }]
+})
+
+media.register({
+  name: 'create-preview-all-response',
+  fields: [{
+    name: 'metadata',
+    type: '@media/metadata',
+    required: true
+  },
+  {
+    name: 'preview',
+    type: '@media/preview-by-size',
+    required: true
+  }]
+})
+
+media.register({
+  name: 'decode-image-request',
+  fields: [{
+    name: 'httpLink',
+    type: 'string',
+    required: true
+  },
+  {
+    name: 'mimetype',
+    type: 'string'
+  }]
+})
+
+media.register({
+  name: 'decode-image-response',
+  fields: [{
+    name: 'metadata',
+    type: '@media/metadata'
+  },
+  {
+    name: 'data',
+    type: 'buffer'
+  }]
+})

package/worker/index.js

@@ -0,0 +1,25 @@
+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.onCreatePreviewAll(media.createPreviewAll)
+rpc.onDecodeImage(media.decodeImage)
+
+uncaughts.on((err) => {
+  log('Uncaught error:', err)
+})

package/worker/media.js

@@ -0,0 +1,105 @@
+import b4a from 'b4a'
+import fs from 'bare-fs'
+import fetch from 'bare-fetch'
+
+import { importCodec } from '../shared/codecs.js'
+import { calculateFitDimensions } from './util'
+
+const DEFAULT_PREVIEW_FORMAT = 'image/webp'
+
+const animatableMimetypes = ['image/webp']
+
+export async function createPreview ({ path, mimetype, maxWidth, maxHeight, format, encoding }) {
+  format = format || DEFAULT_PREVIEW_FORMAT
+
+  const buffer = fs.readFileSync(path)
+  const rgba = await decodeImageToRGBA(buffer, mimetype)
+  const { width, height } = rgba
+
+  return {
+    metadata: {
+      dimensions: { width, height }
+    },
+    preview: await createPreviewFromRGBA(rgba, maxWidth, maxHeight, format, encoding)
+  }
+}
+
+export async function createPreviewAll ({ path, mimetype, maxWidth, maxHeight, format }) {
+  format = format || DEFAULT_PREVIEW_FORMAT
+
+  const buffer = fs.readFileSync(path)
+  const rgba = await decodeImageToRGBA(buffer, mimetype)
+  const { width, height } = rgba
+
+  const [small, medium, large] = await Promise.all([
+    createPreviewFromRGBA(rgba, maxWidth.small, maxHeight.small, format, 'base64'),
+    createPreviewFromRGBA(rgba, maxWidth.medium, maxHeight.medium, format, 'base64'),
+    createPreviewFromRGBA(rgba, maxWidth.large, maxHeight.large, format)
+  ])
+
+  return {
+    metadata: {
+      dimensions: { width, height }
+    },
+    preview: { small, medium, large }
+  }
+}
+
+export async function decodeImage ({ httpLink, mimetype }) {
+  const response = await fetch(httpLink)
+  const buffer = await response.buffer()
+
+  const rgba = await decodeImageToRGBA(buffer, mimetype)
+  const { width, height, data } = rgba
+
+  return {
+    metadata: {
+      dimensions: { width, height }
+    },
+    data
+  }
+}
+
+async function decodeImageToRGBA (buffer, mimetype) {
+  let rgba
+
+  const codec = await importCodec(mimetype)
+
+  if (animatableMimetypes.includes(mimetype)) {
+    const { frames, width, height } = codec.decodeAnimated(buffer)
+    const { data } = frames.next().value
+    rgba = { width, height, data }
+  } else {
+    rgba = codec.decode(buffer)
+  }
+
+  return rgba
+}
+
+async function createPreviewFromRGBA (rgba, maxWidth, maxHeight, format, encoding) {
+  format = format || DEFAULT_PREVIEW_FORMAT
+
+  const { width, height } = rgba
+  let maybeResized, dimensions
+
+  if (maxWidth && maxHeight && (width > maxWidth || height > maxHeight)) {
+    const { resize } = await import('bare-image-resample')
+    dimensions = calculateFitDimensions(width, height, maxWidth, maxHeight)
+    maybeResized = resize(rgba, dimensions.width, dimensions.height)
+  } else {
+    dimensions = { width, height }
+    maybeResized = rgba
+  }
+
+  const codec = await importCodec(format)
+  const encoded = codec.encode(maybeResized)
+
+  const result = encoding === 'base64'
+    ? { inlined: b4a.toString(encoded, 'base64') }
+    : { buffer: encoded }
+
+  return {
+    ...result,
+    metadata: { mimetype: format, dimensions }
+  }
+}

package/worker/util.js

@@ -0,0 +1,16 @@
+export const log = (...args) => console.log('[bare-media]', ...args)
+
+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)
+  }
+}