akarisub 0.1.0 → 0.2.0

package/src/ts/worker.ts

@@ -49,7 +49,8 @@ let lastCurrentTime = 0
 let rate = 1
 let rafId: number | null = null
 let nextIsRaf = false
-let lastCurrentTimeReceivedAt = Date.now()
+const nowMs = (): number => (typeof performance !== 'undefined' ? performance.now() : Date.now())
+let lastCurrentTimeReceivedAt = nowMs()
 let targetFps = 24
 let onDemandRenderMode = false
 let useLocalFonts = false
@@ -105,6 +106,7 @@ let bufferCtx: OffscreenCanvasRenderingContext2D | null = null
 let akariSubHandle = 0
 let subtitleColorSpace: SubtitleColorSpace = null
 let dropAllBlur = false
+let fullTrackWarmupEnabled = false
 let hasBitmapBug = false
 let _Module: AkariSubModule | null = null
 let forceNextDemandRender = false
@@ -132,11 +134,6 @@ interface AkariSubApi {
   removeStyle: (handle: number, index: number) => void
   styleOverrideIndex: (handle: number, index: number) => void
   disableStyleOverride: (handle: number) => void
-  renderBlend: (handle: number, time: number, force: number) => number
-  renderImage: (handle: number, time: number, force: number) => number
-  getChanged: (handle: number) => number
-  getCount: (handle: number) => number
-  getTime: (handle: number) => number
   getTrackColorSpace: (handle: number) => number
   eventGetInt: (handle: number, index: number, field: number) => number
   eventSetInt: (handle: number, index: number, field: number, value: number) => void
@@ -146,13 +143,6 @@ 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
-  rrX: (ptr: number) => number
-  rrY: (ptr: number) => number
-  rrW: (ptr: number) => number
-  rrH: (ptr: number) => number
-  rrImage: (ptr: number) => number
-  rrNext: (ptr: number) => number
-  rrCollect: (resultPtr: number, outPtr: number, maxItems: 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
 }
@@ -173,12 +163,9 @@ const FULL_WARMUP_YIELD_EVERY = 24
 const ASS_TIME_SCALE = 1000
 const imagePool: RenderResultItem[] = new Array(MAX_POOLED_IMAGES)
 let poolInitialized = false
-const RR_META_STRIDE = 6
 // 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
 const RRC_IMG_STRIDE = 5
-let rrMetaPtr = 0
-let rrMetaCapacity = 0
 // Pre-allocated buffer for batch render-collect calls
 let rrcBufPtr = 0
 let rrcBufCapacity = 0
@@ -199,7 +186,7 @@ interface RenderResultItem {
   h: number
   x: number
   y: number
-  image: number | ImageBitmap | ArrayBuffer
+  image: number | ImageBitmap | Uint8ClampedArray
 }
 
 const initPool = (): void => {
@@ -217,28 +204,6 @@ const getPooledItem = (index: number): RenderResultItem => {
   return { w: 0, h: 0, x: 0, y: 0, image: 0 }
 }
 
-const ensureRenderMetaBuffer = (imageCount: number): void => {
-  if (!_Module || imageCount <= 0) return
-  if (rrMetaCapacity >= imageCount && rrMetaPtr) return
-
-  const nextCapacity = Math.max(imageCount, rrMetaCapacity * 2 || 64)
-  const nextSizeBytes = nextCapacity * RR_META_STRIDE * Int32Array.BYTES_PER_ELEMENT
-
-  if (rrMetaPtr) {
-    _Module._free(rrMetaPtr)
-    rrMetaPtr = 0
-    rrMetaCapacity = 0
-  }
-
-  rrMetaPtr = _Module._malloc(nextSizeBytes)
-  if (!rrMetaPtr) {
-    rrMetaCapacity = 0
-    throw new Error('Failed to allocate render metadata buffer')
-  }
-
-  rrMetaCapacity = nextCapacity
-}
-
 /**
  * Ensure the batch render-collect buffer is large enough.
  * Layout: [changed, count, time, (x, y, w, h, image_ptr) * N]
@@ -281,6 +246,10 @@ const prewarmRenderer = (time: number): void => {
   }
 }
 
+const syncTotalEventsMetric = (): void => {
+  metrics.totalEvents = akariSubHandle ? requireApi().getEventCount(akariSubHandle) : 0
+}
+
 const getFirstEventStartTime = (): number | null => {
   if (!akariSubHandle) return null
 
@@ -377,7 +346,7 @@ const stopWarmup = (): void => {
 }
 
 const scheduleFullTrackWarmup = (): void => {
-  if (fullTrackWarmupPromise || !akariSubHandle) return
+  if (!fullTrackWarmupEnabled || fullTrackWarmupPromise || !akariSubHandle) return
 
   fullTrackWarmupPromise = (async () => {
     await sleep(0)
@@ -778,6 +747,7 @@ self.setTrack = ({ content }: { content: string }): void => {
   withCString(content, (contentPtr) => {
     api.createTrackMem(handle, contentPtr)
   })
+  syncTotalEventsMetric()
   firstTrackEventStartTime = getFirstEventStartTime()
   subtitleColorSpace = libassYCbCrMap[api.getTrackColorSpace(handle)]
   forceNextDemandRender = true
@@ -795,6 +765,7 @@ self.freeTrack = (): void => {
   const api = requireApi()
   const handle = requireHandle()
   api.removeTrack(handle)
+  syncTotalEventsMetric()
 }
 
 self.setTrackByUrl = ({ url }: { url: string }): void => {
@@ -808,7 +779,7 @@ self.setTrackByUrl = ({ url }: { url: string }): void => {
 let _isPaused = true
 
 const getCurrentTime = (): number => {
-  const diff = (Date.now() - lastCurrentTimeReceivedAt) / 1000
+  const diff = (nowMs() - lastCurrentTimeReceivedAt) / 1000
   if (_isPaused) {
     return lastCurrentTime
   } else {
@@ -822,7 +793,7 @@ const getCurrentTime = (): number => {
 
 const setCurrentTime = (currentTime: number): void => {
   lastCurrentTime = currentTime
-  lastCurrentTimeReceivedAt = Date.now()
+  lastCurrentTimeReceivedAt = nowMs()
 
   if (onDemandRenderMode) {
     return
@@ -859,7 +830,7 @@ const setIsPaused = (isPaused: boolean): void => {
         rafId = null
       }
     } else {
-      lastCurrentTimeReceivedAt = Date.now()
+      lastCurrentTimeReceivedAt = nowMs()
       rafId = requestAnimationFrame(renderLoop)
     }
   }
@@ -960,8 +931,6 @@ const render = (time: number, force?: boolean | number): void => {
     metrics.cacheHits++
   }
 
-  metrics.totalEvents = api.getEventCount(handle)
-
   if (debug) {
     const decodeEndTime = performance.now()
     const renderEndTimeWasm = headerView[2]
@@ -998,7 +967,7 @@ const render = (time: number, force?: boolean | number): void => {
 
         const pointer = meta[metaOffset + 4]
         const byteLength = item.w * item.h * 4
-        const rawData = self.HEAPU8C.slice(pointer, pointer + byteLength)
+        const rawData = new Uint8ClampedArray(self.wasmMemory.buffer, pointer, byteLength)
 
         const imageData = new ImageData(rawData as Uint8ClampedArray<ArrayBuffer>, item.w, item.h)
 
@@ -1039,9 +1008,11 @@ const render = (time: number, force?: boolean | number): void => {
 
         if (!offCanvasCtx) {
           const imagePtr = item.image as number
-          const buf = self.wasmMemory.buffer.slice(imagePtr, imagePtr + item.w * item.h * 4)
-          buffers.push(buf)
-          item.image = buf
+          const byteLength = item.w * item.h * 4
+          const copiedData = new Uint8ClampedArray(byteLength)
+          copiedData.set(self.HEAPU8C.subarray(imagePtr, imagePtr + byteLength))
+          buffers.push(copiedData.buffer)
+          item.image = copiedData
         }
         images[i] = item
       }
@@ -1056,7 +1027,7 @@ const render = (time: number, force?: boolean | number): void => {
 
 self.demand = ({ time }: { time: number }): void => {
   lastCurrentTime = time
-  lastCurrentTimeReceivedAt = Date.now()
+  lastCurrentTimeReceivedAt = nowMs()
   const force = forceNextDemandRender ? 1 : 0
   forceNextDemandRender = false
   render(time, force)
@@ -1132,11 +1103,7 @@ const paintImages = ({
 
           bufferCtx!.putImageData(
             new ImageData(
-              new Uint8ClampedArray(
-                rawData.buffer,
-                rawData.byteOffset,
-                rawData.byteLength
-              ) as Uint8ClampedArray<ArrayBuffer>,
+              rawData as Uint8ClampedArray<ArrayBuffer>,
               imgW,
               imgH
             ),
@@ -1188,7 +1155,7 @@ const paintImages = ({
 const requestAnimationFrame = self.requestAnimationFrame ? self.requestAnimationFrame.bind(self) : ((): ((func: () => void) => number) => {
   let nextRAF = 0
   return (func: () => void): number => {
-    const now = Date.now()
+    const now = nowMs()
     if (nextRAF === 0) {
       nextRAF = now + 1000 / targetFps
     } else {
@@ -1209,6 +1176,7 @@ const cancelAnimationFrame = self.cancelAnimationFrame ? self.cancelAnimationFra
 
 self.init = async (data: any): Promise<void> => {
   hasBitmapBug = data.hasBitmapBug
+  fullTrackWarmupEnabled = !!data.fullTrackWarmup
   if (typeof data.initialTime === 'number' && Number.isFinite(data.initialTime)) {
     lastCurrentTime = data.initialTime
   }
@@ -1254,11 +1222,6 @@ self.init = async (data: any): Promise<void> => {
       removeStyle: Module._akarisub_remove_style,
       styleOverrideIndex: Module._akarisub_style_override_index,
       disableStyleOverride: Module._akarisub_disable_style_override,
-      renderBlend: Module._akarisub_render_blend,
-      renderImage: Module._akarisub_render_image,
-      getChanged: Module._akarisub_get_changed,
-      getCount: Module._akarisub_get_count,
-      getTime: Module._akarisub_get_time,
       getTrackColorSpace: Module._akarisub_get_track_color_space,
       eventGetInt: Module._akarisub_event_get_int,
       eventSetInt: Module._akarisub_event_set_int,
@@ -1268,13 +1231,6 @@ 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,
-      rrX: Module._akarisub_render_result_x,
-      rrY: Module._akarisub_render_result_y,
-      rrW: Module._akarisub_render_result_w,
-      rrH: Module._akarisub_render_result_h,
-      rrImage: Module._akarisub_render_result_image,
-      rrNext: Module._akarisub_render_result_next,
-      rrCollect: Module._akarisub_render_result_collect,
       renderBlendCollect: Module._akarisub_render_blend_collect,
       renderImageCollect: Module._akarisub_render_image_collect
     }
@@ -1535,11 +1491,10 @@ self.init = async (data: any): Promise<void> => {
       if (debug) console.log('[AkariSub] Font reload complete')
     }
 
-    processAvailableFonts(subContent)
-
     withCString(subContent, (subPtr) => {
       requireApi().createTrackMem(requireHandle(), subPtr)
     })
+    syncTotalEventsMetric()
     firstTrackEventStartTime = getFirstEventStartTime()
     subtitleColorSpace = libassYCbCrMap[requireApi().getTrackColorSpace(requireHandle())]
     requireApi().setDropAnimations(requireHandle(), data.dropAllAnimations || 0)
@@ -1576,16 +1531,16 @@ self.init = async (data: any): Promise<void> => {
 
 self.offscreenCanvas = ({ transferable }: { transferable: [OffscreenCanvas] }): void => {
   offCanvas = transferable[0]
-  offCanvasCtx = offCanvas.getContext('2d')
+  offCanvasCtx = offCanvas.getContext('2d', { desynchronized: true })
   if (!asyncRender) {
-    bufferCanvas = new OffscreenCanvas(self.height, self.width)
+    bufferCanvas = new OffscreenCanvas(self.width, self.height)
     bufferCtx = bufferCanvas.getContext('2d', { desynchronized: true })
   }
   offscreenRender = true
 }
 
 self.detachOffscreen = (): void => {
-  offCanvas = new OffscreenCanvas(self.height, self.width)
+  offCanvas = new OffscreenCanvas(self.width, self.height)
   offCanvasCtx = offCanvas.getContext('2d', { desynchronized: true })
   offscreenRender = 'hybrid'
 }
@@ -1630,11 +1585,6 @@ self.destroy = (): void => {
   firstTrackEventStartTime = null
 
   if (_Module) {
-    if (rrMetaPtr) {
-      _Module._free(rrMetaPtr)
-      rrMetaPtr = 0
-      rrMetaCapacity = 0
-    }
     if (rrcBufPtr) {
       _Module._free(rrcBufPtr)
       rrcBufPtr = 0
@@ -1645,6 +1595,7 @@ self.destroy = (): void => {
     requireApi().destroy(akariSubHandle)
     akariSubHandle = 0
   }
+  metrics.totalEvents = 0
 }
 
 self.setAsyncRender = ({ value }: { value: boolean }): void => {
@@ -1749,6 +1700,7 @@ const readStyle = (index: number): ASSStyle => {
 self.createEvent = ({ event }: { event: Partial<ASSEvent> }): void => {
   const index = requireApi().allocEvent(requireHandle())
   if (index >= 0) applyEventFields(index, event)
+  syncTotalEventsMetric()
 }
 
 self.getEvents = (): void => {
@@ -1767,6 +1719,7 @@ self.setEvent = ({ event, index }: { event: Partial<ASSEvent>; index: number }):
 
 self.removeEvent = ({ index }: { index: number }): void => {
   requireApi().removeEvent(requireHandle(), index)
+  syncTotalEventsMetric()
 }
 
 // =============================================================================