akarisub 0.2.0 → 0.2.2

package/src/ts/worker.ts

@@ -12,6 +12,7 @@ import type {
   ASSEvent,
   ASSStyle,
   AkariSubModule,
+  EncryptedSubtitleContent,
   SubtitleColorSpace,
   WorkerInboundMessage
 } from './types'
@@ -143,6 +144,8 @@ interface AkariSubApi {
   styleSetNum: (handle: number, index: number, field: number, value: number) => void
   styleGetStr: (handle: number, index: number, field: number) => number
   styleSetStr: (handle: number, index: number, field: number, valuePtr: number) => void
+  getEventTimeRange: (handle: number, outPtr: number) => number
+  getEmptyWindow: (handle: number, tm: number, outPtr: number) => number
   renderBlendCollect: (handle: number, time: number, force: number, outPtr: number, maxItems: number) => number
   renderImageCollect: (handle: number, time: number, force: number, outPtr: number, maxItems: number) => number
 }
@@ -161,7 +164,7 @@ const FULL_WARMUP_CAP_SECONDS = 30
 const FULL_WARMUP_STEP_SECONDS = 1
 const FULL_WARMUP_YIELD_EVERY = 24
 const ASS_TIME_SCALE = 1000
-const imagePool: RenderResultItem[] = new Array(MAX_POOLED_IMAGES)
+const imagePool: RenderResultItem[] = []
 let poolInitialized = false
 // Batch render-collect buffer: 3 header ints (changed, count, time) + 5 ints per image (x, y, w, h, image_ptr)
 const RRC_HEADER_INTS = 3
@@ -169,6 +172,13 @@ const RRC_IMG_STRIDE = 5
 // Pre-allocated buffer for batch render-collect calls
 let rrcBufPtr = 0
 let rrcBufCapacity = 0
+// Cached views over the render-collect buffer; refreshed when the wasm memory
+// grows (buffer identity changes) or the buffer is reallocated/resized.
+let rrcHeaderView: Int32Array | null = null
+let rrcMetaView: Int32Array | null = null
+let rrcViewsBuffer: ArrayBufferLike | null = null
+let rrcViewsPtr = 0
+let rrcViewsCapacity = 0
 const frameImages: RenderResultItem[] = []
 const frameArrayBuffers: ArrayBuffer[] = []
 const frameBitmapPromises: Promise<ImageBitmap>[] = []
@@ -178,6 +188,7 @@ let warmupEndTime = 0
 let warmupEnabled = false
 let firstTrackEventStartTime: number | null = null
 let fullTrackWarmupPromise: Promise<void> | null = null
+let protectedTrackContent = false
 
 const sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))
 
@@ -198,10 +209,13 @@ const initPool = (): void => {
 }
 
 const getPooledItem = (index: number): RenderResultItem => {
-  if (index < MAX_POOLED_IMAGES) {
-    return imagePool[index]
+  let item = imagePool[index]
+  if (!item) {
+    // Grow the pool on demand so frames with many images reuse items too
+    item = { w: 0, h: 0, x: 0, y: 0, image: 0 }
+    imagePool[index] = item
   }
-  return { w: 0, h: 0, x: 0, y: 0, image: 0 }
+  return item
 }
 
 /**
@@ -232,6 +246,22 @@ const ensureRenderCollectBuffer = (maxImages: number): void => {
   rrcBufCapacity = nextCapacity
 }
 
+const refreshRrcViews = (): void => {
+  const buffer = self.wasmMemory.buffer
+  if (rrcHeaderView && rrcViewsBuffer === buffer && rrcViewsPtr === rrcBufPtr && rrcViewsCapacity === rrcBufCapacity) {
+    return
+  }
+  rrcHeaderView = new Int32Array(buffer, rrcBufPtr, RRC_HEADER_INTS)
+  rrcMetaView = new Int32Array(
+    buffer,
+    rrcBufPtr + RRC_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT,
+    rrcBufCapacity - RRC_HEADER_INTS
+  )
+  rrcViewsBuffer = buffer
+  rrcViewsPtr = rrcBufPtr
+  rrcViewsCapacity = rrcBufCapacity
+}
+
 const prewarmRenderer = (time: number): void => {
   if (!akariSubHandle) return
 
@@ -250,55 +280,52 @@ const syncTotalEventsMetric = (): void => {
   metrics.totalEvents = akariSubHandle ? requireApi().getEventCount(akariSubHandle) : 0
 }
 
-const getFirstEventStartTime = (): number | null => {
-  if (!akariSubHandle) return null
+const getTrackEventTimeRange = (): { start: number; end: number } | null => {
+  if (!akariSubHandle || !_Module) return null
 
   const api = requireApi()
   const handle = requireHandle()
-  const count = api.getEventCount(handle)
-  if (count <= 0) return null
+  const outPtr = _Module._malloc(2 * Int32Array.BYTES_PER_ELEMENT)
+  if (!outPtr) return null
 
-  let firstStart = Number.POSITIVE_INFINITY
+  try {
+    if (!api.getEventTimeRange(handle, outPtr)) return null
 
-  for (let i = 0; i < count; i++) {
-    const start = api.eventGetInt(handle, i, EVENT_INT_FIELDS.Start) / ASS_TIME_SCALE
-    if (Number.isFinite(start) && start < firstStart) {
-      firstStart = start
-    }
+    const view = new Int32Array(self.wasmMemory.buffer, outPtr, 2)
+    const start = Math.max(0, view[0] / ASS_TIME_SCALE)
+    const end = Math.max(start, view[1] / ASS_TIME_SCALE)
+    return { start, end }
+  } finally {
+    _Module._free(outPtr)
   }
-
-  if (!Number.isFinite(firstStart)) return null
-  return Math.max(0, firstStart)
 }
 
-const getTrackEventTimeRange = (): { start: number; end: number } | null => {
-  if (!akariSubHandle) return null
-
-  const api = requireApi()
-  const handle = requireHandle()
-  const count = api.getEventCount(handle)
-  if (count <= 0) return null
+const getFirstEventStartTime = (): number | null => {
+  return getTrackEventTimeRange()?.start ?? null
+}
 
-  let start = Number.POSITIVE_INFINITY
-  let end = 0
+let emptyWindowFrom = -1
+let emptyWindowUntil = -1
 
-  for (let i = 0; i < count; i++) {
-    const eventStart = api.eventGetInt(handle, i, EVENT_INT_FIELDS.Start) / ASS_TIME_SCALE
-    const eventDuration = Math.max(0, api.eventGetInt(handle, i, EVENT_INT_FIELDS.Duration) / ASS_TIME_SCALE)
+const invalidateEmptyWindow = (): void => {
+  emptyWindowFrom = -1
+  emptyWindowUntil = -1
+}
 
-    if (!Number.isFinite(eventStart)) continue
+const computeEmptyWindow = (time: number): void => {
+  if (!akariSubHandle || !_Module) return
 
-    const eventEnd = eventStart + eventDuration
-    if (eventStart < start) start = eventStart
-    if (eventEnd > end) end = eventEnd
-  }
+  const outPtr = _Module._malloc(Int32Array.BYTES_PER_ELEMENT)
+  if (!outPtr) return
 
-  if (!Number.isFinite(start)) return null
-  if (end < start) end = start
+  try {
+    if (!requireApi().getEmptyWindow(requireHandle(), time, outPtr)) return
 
-  return {
-    start: Math.max(0, start),
-    end: Math.max(0, end)
+    const nextStart = new Int32Array(self.wasmMemory.buffer, outPtr, 1)[0]
+    emptyWindowFrom = time
+    emptyWindowUntil = nextStart < 0 ? Number.POSITIVE_INFINITY : nextStart / ASS_TIME_SCALE
+  } finally {
+    _Module._free(outPtr)
   }
 }
 
@@ -497,6 +524,101 @@ const withCString = <T>(input: string, callback: (ptr: number) => T): T => {
   }
 }
 
+const toUint8Array = (content: Uint8Array | ArrayBuffer): Uint8Array => {
+  return content instanceof Uint8Array ? content : new Uint8Array(content)
+}
+
+const isBinaryContent = (content: string | Uint8Array | ArrayBuffer): content is Uint8Array | ArrayBuffer => {
+  return content instanceof Uint8Array || content instanceof ArrayBuffer
+}
+
+const withCBytes = <T>(input: Uint8Array, callback: (ptr: number) => T): T => {
+  if (!_Module) throw new Error('AkariSub module is not initialized')
+
+  const ptr = _Module._malloc(input.length + 1)
+  if (!ptr) throw new Error('Failed to allocate subtitle content')
+
+  try {
+    self.HEAPU8.set(input, ptr)
+    self.HEAPU8[ptr + input.length] = 0
+    return callback(ptr)
+  } finally {
+    self.HEAPU8.fill(0, ptr, ptr + input.length + 1)
+    _Module._free(ptr)
+  }
+}
+
+const decryptV2Payload = async (encrypted: ArrayBuffer, contentKey: CryptoKey): Promise<Uint8Array> => {
+  const data = new Uint8Array(encrypted)
+  const keyIdSize = 8
+  const nonceSize = 12
+  const headerSize = 1 + keyIdSize + nonceSize
+
+  if (data.length < headerSize + 16) {
+    throw new Error('Ciphertext too short for v2 subtitle payload')
+  }
+
+  if (data[0] !== 2) {
+    throw new Error('Unsupported encrypted subtitle protocol version')
+  }
+
+  const header = data.subarray(0, 1 + keyIdSize)
+  const nonce = data.subarray(1 + keyIdSize, headerSize)
+  const ciphertext = data.subarray(headerSize)
+  const decrypted = await crypto.subtle.decrypt(
+    {
+      name: 'AES-GCM',
+      iv: nonce.buffer.slice(nonce.byteOffset, nonce.byteOffset + nonce.byteLength),
+      additionalData: header.buffer.slice(header.byteOffset, header.byteOffset + header.byteLength),
+      tagLength: 128
+    },
+    contentKey,
+    ciphertext.buffer.slice(ciphertext.byteOffset, ciphertext.byteOffset + ciphertext.byteLength)
+  )
+
+  return new Uint8Array(decrypted)
+}
+
+const decryptSubtitleContent = async (content: EncryptedSubtitleContent): Promise<Uint8Array> => {
+  if (content.encrypted) {
+    return decryptV2Payload(content.encrypted, content.contentKey)
+  }
+
+  const chunks = content.encryptedChunks || []
+  if (chunks.length === 0) {
+    throw new Error('Encrypted subtitle content is empty')
+  }
+
+  const decryptedChunks = await Promise.all(chunks.map((chunk) => decryptV2Payload(chunk, content.contentKey)))
+  const totalLength = decryptedChunks.reduce((sum, chunk) => sum + chunk.length, 0)
+  const result = new Uint8Array(totalLength)
+  let offset = 0
+
+  for (const chunk of decryptedChunks) {
+    result.set(chunk, offset)
+    chunk.fill(0)
+    offset += chunk.length
+  }
+
+  return result
+}
+
+const createTrackFromBytes = (content: Uint8Array): void => {
+  const api = requireApi()
+  const handle = requireHandle()
+  withCBytes(content, (contentPtr) => {
+    api.createTrackMem(handle, contentPtr)
+  })
+}
+
+const createTrackFromString = (content: string): void => {
+  const api = requireApi()
+  const handle = requireHandle()
+  withCString(content, (contentPtr) => {
+    api.createTrackMem(handle, contentPtr)
+  })
+}
+
 const requireApi = (): AkariSubApi => {
   if (!akariSubApi) throw new Error('AkariSub API is not initialized')
   return akariSubApi
@@ -733,25 +855,49 @@ const readAsync = (url: string, load: (data: ArrayBuffer) => void, err: (e: any)
 // Track Management
 // =============================================================================
 
-self.setTrack = ({ content }: { content: string }): void => {
+const finishTrackLoad = (): void => {
+  const api = requireApi()
+  const handle = requireHandle()
+  syncTotalEventsMetric()
+  firstTrackEventStartTime = getFirstEventStartTime()
+  subtitleColorSpace = libassYCbCrMap[api.getTrackColorSpace(handle)]
+  forceNextDemandRender = true
+  postMessage({ target: 'verifyColorSpace', subtitleColorSpace })
+  postMessage({ target: 'trackReady' })
+}
+
+self.setTrack = ({ content }: { content: string | Uint8Array | ArrayBuffer }): void => {
   stopWarmup()
   fullTrackWarmupPromise = null
+  protectedTrackContent = false
+
+  if (isBinaryContent(content)) {
+    createTrackFromBytes(toUint8Array(content))
+    finishTrackLoad()
+    return
+  }
 
   processAvailableFonts(content)
 
   if (clampPos) content = fixPlayRes(content)
   if (dropAllBlur) content = dropBlur(content)
 
-  const api = requireApi()
-  const handle = requireHandle()
-  withCString(content, (contentPtr) => {
-    api.createTrackMem(handle, contentPtr)
-  })
-  syncTotalEventsMetric()
-  firstTrackEventStartTime = getFirstEventStartTime()
-  subtitleColorSpace = libassYCbCrMap[api.getTrackColorSpace(handle)]
-  forceNextDemandRender = true
-  postMessage({ target: 'verifyColorSpace', subtitleColorSpace })
+  createTrackFromString(content)
+  finishTrackLoad()
+}
+
+self.setEncryptedTrack = async ({ content }: { content: EncryptedSubtitleContent }): Promise<void> => {
+  stopWarmup()
+  fullTrackWarmupPromise = null
+  protectedTrackContent = true
+
+  const decrypted = await decryptSubtitleContent(content)
+  try {
+    createTrackFromBytes(decrypted)
+  } finally {
+    decrypted.fill(0)
+  }
+  finishTrackLoad()
 }
 
 self.getColorSpace = (): void => {
@@ -762,6 +908,7 @@ self.freeTrack = (): void => {
   stopWarmup()
   fullTrackWarmupPromise = null
   firstTrackEventStartTime = null
+  protectedTrackContent = false
   const api = requireApi()
   const handle = requireHandle()
   api.removeTrack(handle)
@@ -890,6 +1037,13 @@ const render = (time: number, force?: boolean | number): void => {
     return
   }
 
+  // Inside a known-empty window the output cannot change: skip the WASM call
+  if (!force && emptyWindowFrom >= 0 && time >= emptyWindowFrom && time < emptyWindowUntil) {
+    metrics.cacheHits++
+    postMessage({ target: 'unbusy' })
+    return
+  }
+
   renderInFlight = true
   initPool() // Ensure pool is ready
 
@@ -910,9 +1064,15 @@ const render = (time: number, force?: boolean | number): void => {
       ? api.renderBlendCollect(handle, time, forceInt, rrcBufPtr, rrcBufCapacity)
       : api.renderImageCollect(handle, time, forceInt, rrcBufPtr, rrcBufCapacity)
 
-  const headerView = new Int32Array(self.wasmMemory.buffer, rrcBufPtr, RRC_HEADER_INTS)
+  // Refresh after the WASM call: rendering may have grown the memory
+  refreshRrcViews()
+  const headerView = rrcHeaderView!
   const changed = headerView[0]
-  const imageCount = headerView[1]
+
+  // Frame produced no images: ask how long renders can be skipped.
+  if (headerView[1] === 0 && (emptyWindowFrom < 0 || time < emptyWindowFrom || time >= emptyWindowUntil)) {
+    computeEmptyWindow(time)
+  }
 
   // Update metrics
   const renderEndTime = performance.now()
@@ -947,8 +1107,7 @@ const render = (time: number, force?: boolean | number): void => {
 
     if (written === 0) return paintImages({ images, buffers, times })
 
-    const imgDataOffset = rrcBufPtr + RRC_HEADER_INTS * Int32Array.BYTES_PER_ELEMENT
-    const meta = new Int32Array(self.wasmMemory.buffer, imgDataOffset, written * RRC_IMG_STRIDE)
+    const meta = rrcMetaView!
 
     const useAsyncBitmapPath = asyncRender && offscreenRender !== true
 
@@ -967,7 +1126,12 @@ const render = (time: number, force?: boolean | number): void => {
 
         const pointer = meta[metaOffset + 4]
         const byteLength = item.w * item.h * 4
-        const rawData = new Uint8ClampedArray(self.wasmMemory.buffer, pointer, byteLength)
+        let rawData = new Uint8ClampedArray(self.wasmMemory.buffer, pointer, byteLength)
+        if (hasBitmapBug) {
+          // Browsers with the partial-bitmap bug mis-render ImageData backed
+          // by a view into a larger buffer; give them a standalone copy.
+          rawData = rawData.slice()
+        }
 
         const imageData = new ImageData(rawData as Uint8ClampedArray<ArrayBuffer>, item.w, item.h)
 
@@ -997,6 +1161,20 @@ const render = (time: number, force?: boolean | number): void => {
         }
       })
     } else {
+      // When posting to the main thread, copy all image pixels into one
+      // transferable buffer instead of allocating/transferring one per image.
+      let copyTarget: Uint8ClampedArray<ArrayBuffer> | null = null
+      let copyOffset = 0
+      if (!offCanvasCtx) {
+        let totalBytes = 0
+        for (let i = 0; i < written; ++i) {
+          const metaOffset = i * RRC_IMG_STRIDE
+          totalBytes += meta[metaOffset + 2] * meta[metaOffset + 3] * 4
+        }
+        copyTarget = new Uint8ClampedArray(totalBytes)
+        buffers.push(copyTarget.buffer)
+      }
+
       for (let i = 0; i < written; ++i) {
         const metaOffset = i * RRC_IMG_STRIDE
         const item = getPooledItem(i)
@@ -1006,13 +1184,13 @@ const render = (time: number, force?: boolean | number): void => {
         item.h = meta[metaOffset + 3]
         item.image = meta[metaOffset + 4]
 
-        if (!offCanvasCtx) {
+        if (copyTarget) {
           const imagePtr = item.image as number
           const byteLength = item.w * item.h * 4
-          const copiedData = new Uint8ClampedArray(byteLength)
+          const copiedData = copyTarget.subarray(copyOffset, copyOffset + byteLength)
           copiedData.set(self.HEAPU8C.subarray(imagePtr, imagePtr + byteLength))
-          buffers.push(copiedData.buffer)
           item.image = copiedData
+          copyOffset += byteLength
         }
         images[i] = item
       }
@@ -1231,6 +1409,8 @@ self.init = async (data: any): Promise<void> => {
       styleSetNum: Module._akarisub_style_set_num,
       styleGetStr: Module._akarisub_style_get_str,
       styleSetStr: Module._akarisub_style_set_str,
+      getEventTimeRange: Module._akarisub_get_event_time_range,
+      getEmptyWindow: Module._akarisub_get_empty_window,
       renderBlendCollect: Module._akarisub_render_blend_collect,
       renderImageCollect: Module._akarisub_render_image_collect
     }
@@ -1420,19 +1600,34 @@ self.init = async (data: any): Promise<void> => {
     }
 
     let subContent = data.subContent
-    if (!subContent) subContent = read_(data.subUrl) as string
+    let decryptedSubContent: Uint8Array | null = null
+
+    if (data.encryptedSubContent) {
+      protectedTrackContent = true
+      decryptedSubContent = await decryptSubtitleContent(data.encryptedSubContent)
+      subContent = decryptedSubContent
+    } else {
+      protectedTrackContent = false
+      if (!subContent) subContent = read_(data.subUrl) as string
+    }
 
     // For large files, emit partial_ready early to allow playback to start
     // while font loading and track parsing continues in the background
-    const isLargeSubtitle = subContent.length > 500000
+    const isLargeSubtitle = typeof subContent === 'string'
+      ? subContent.length > 500000
+      : toUint8Array(subContent).byteLength > 500000
     if (isLargeSubtitle) {
       postMessage({ target: 'partial_ready' })
       if (debug) console.log('[AkariSub] Large subtitle detected, emitting partial_ready early')
     }
 
-    processAvailableFonts(subContent)
-    if (clampPos) subContent = fixPlayRes(subContent)
-    if (dropAllBlur) subContent = dropBlur(subContent)
+    if (typeof subContent === 'string') {
+      processAvailableFonts(subContent)
+      if (clampPos) subContent = fixPlayRes(subContent)
+      if (dropAllBlur) subContent = dropBlur(subContent)
+    } else if (debug && (clampPos || dropAllBlur)) {
+      console.warn('[AkariSub] Text rewrite options are skipped for protected binary subtitle content')
+    }
 
     // Load attached/preloaded fonts before ready to avoid runtime font churn during first playback.
     let hasAttachedFonts = false
@@ -1491,9 +1686,15 @@ self.init = async (data: any): Promise<void> => {
       if (debug) console.log('[AkariSub] Font reload complete')
     }
 
-    withCString(subContent, (subPtr) => {
-      requireApi().createTrackMem(requireHandle(), subPtr)
-    })
+    if (typeof subContent === 'string') {
+      createTrackFromString(subContent)
+    } else {
+      try {
+        createTrackFromBytes(toUint8Array(subContent))
+      } finally {
+        decryptedSubContent?.fill(0)
+      }
+    }
     syncTotalEventsMetric()
     firstTrackEventStartTime = getFirstEventStartTime()
     subtitleColorSpace = libassYCbCrMap[requireApi().getTrackColorSpace(requireHandle())]
@@ -1589,6 +1790,11 @@ self.destroy = (): void => {
       _Module._free(rrcBufPtr)
       rrcBufPtr = 0
       rrcBufCapacity = 0
+      rrcHeaderView = null
+      rrcMetaView = null
+      rrcViewsBuffer = null
+      rrcViewsPtr = 0
+      rrcViewsCapacity = 0
     }
   }
   if (akariSubHandle) {
@@ -1708,7 +1914,13 @@ self.getEvents = (): void => {
   const api = requireApi()
   const count = api.getEventCount(requireHandle())
   for (let i = 0; i < count; i++) {
-    events.push({ ...readEvent(i), _index: i })
+    const event = { ...readEvent(i), _index: i }
+    if (protectedTrackContent) {
+      event.Name = ''
+      event.Effect = ''
+      event.Text = ''
+    }
+    events.push(event)
   }
   postMessage({ target: 'getEvents', events })
 }
@@ -1810,10 +2022,31 @@ self.getStyleCount = (): void => {
 // Message Handler
 // =============================================================================
 
+const RENDER_SAFE_TARGETS = new Set([
+  'demand',
+  'video',
+  'getEvents',
+  'getStyles',
+  'getStats',
+  'resetStats',
+  'getEventCount',
+  'getStyleCount',
+  'getColorSpace'
+])
+
 onmessage = ({ data }: MessageEvent): void => {
-  if (self[data.target]) {
-    self[data.target](data)
-  } else {
+  if (!self[data.target]) {
     throw new Error('Unknown event target ' + data.target)
   }
+
+  if (!RENDER_SAFE_TARGETS.has(data.target)) {
+    invalidateEmptyWindow()
+  }
+
+  Promise.resolve(self[data.target](data)).catch((error) => {
+    postMessage({
+      target: 'error',
+      error: error instanceof Error ? error.message : String(error)
+    })
+  })
 }