bare-media 1.2.1 → 1.4.0

package/worker/media.js

@@ -3,37 +3,118 @@ import fs from 'bare-fs'
 import fetch from 'bare-fetch'
 import getMimeType from 'get-mime-type'
 
-import { importCodec } from '../shared/codecs.js'
+import { importCodec, supportsQuality } 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 }) {
+export async function createPreview({
+  path,
+  mimetype,
+  maxWidth,
+  maxHeight,
+  maxFrames,
+  maxBytes,
+  format,
+  encoding
+}) {
   mimetype = mimetype || getMimeType(path)
   format = format || DEFAULT_PREVIEW_FORMAT
 
   const buffer = fs.readFileSync(path)
-  const rgba = await decodeImageToRGBA(buffer, mimetype)
+  const rgba = await decodeImageToRGBA(buffer, mimetype, maxFrames)
   const { width, height } = rgba
 
-  const { dimensions, rgba: maybeResizedRGBA } = await resizeRGBA(rgba, width, height, maxWidth, maxHeight)
+  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
 
-  const encoded = await encodeImageFromRGBA(maybeResizedRGBA, format, encoding)
+    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 },
+      metadata: {
+        mimetype: format,
+        dimensions: {
+          width: maybeResizedRGBA.width,
+          height: maybeResizedRGBA.height
+        }
+      },
       ...encoded
     }
   }
 }
 
-export async function decodeImage ({ path, httpLink, mimetype }) {
+export async function decodeImage({ path, httpLink, mimetype }) {
   let buffer
 
   if (path) {
@@ -54,15 +135,19 @@ export async function decodeImage ({ path, httpLink, mimetype }) {
   }
 }
 
-async function decodeImageToRGBA (buffer, mimetype) {
+async function decodeImageToRGBA(buffer, mimetype, maxFrames) {
   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 }
+    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)
   }
@@ -70,26 +155,50 @@ async function decodeImageToRGBA (buffer, mimetype) {
   return rgba
 }
 
-async function encodeImageFromRGBA (rgba, format, encoding) {
+async function encodeImageFromRGBA(rgba, format, opts) {
   const codec = await importCodec(format)
-  const encoded = codec.encode(rgba)
 
-  return encoding === 'base64'
-    ? { inlined: b4a.toString(encoded, 'base64') }
-    : { buffer: encoded }
+  let encoded
+  if (Array.isArray(rgba.frames)) {
+    encoded = codec.encodeAnimated(rgba, opts)
+  } else {
+    encoded = codec.encode(rgba, opts)
+  }
+
+  return encoded
 }
 
-async function resizeRGBA (rgba, width, height, maxWidth, maxHeight) {
-  let maybeResizedRGBA, dimensions
+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')
-    dimensions = calculateFitDimensions(width, height, maxWidth, maxHeight)
-    maybeResizedRGBA = resize(rgba, dimensions.width, dimensions.height)
+    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 {
-    dimensions = { width, height }
     maybeResizedRGBA = rgba
   }
 
-  return { dimensions, rgba: maybeResizedRGBA }
+  return maybeResizedRGBA
 }

package/worker/util.js

@@ -1,6 +1,6 @@
 export const log = (...args) => console.log('[bare-media]', ...args)
 
-export function calculateFitDimensions (width, height, maxWidth, maxHeight) {
+export function calculateFitDimensions(width, height, maxWidth, maxHeight) {
   if (width <= maxWidth && height <= maxHeight) {
     return { width, height }
   }