@camera.ui/server 0.0.50-internal.0 → 0.0.50-internal.2

package/src/decoder/wasm/assembly/index.ts

@@ -1,890 +0,0 @@
-enum WASMImageFormat {
-  GRAY = 1,
-  RGB = 2,
-  RGBA = 3,
-}
-
-enum WASMInputFormat {
-  YUV = 1,
-  RGB = 2,
-  RGBA = 3,
-  GRAY = 4,
-}
-
-// Konstanten für die Konvertierung als SIMD-Vektoren
-const Y_MULTIPLIER = v128.splat<i32>(298);
-const R_ADD = v128.splat<i32>(409);
-const G_ADD1 = v128.splat<i32>(-100);
-const G_ADD2 = v128.splat<i32>(-208);
-const B_ADD = v128.splat<i32>(516);
-const SHIFT = 8;
-const CLAMP_MIN = v128.splat<i32>(0);
-const CLAMP_MAX = v128.splat<i32>(255);
-
-class StackBlurNode {
-  value: u8 = 0;
-  next: StackBlurNode | null = null;
-}
-
-const mulTable: i32[] = [
-  512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482,
-  454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482,
-  468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428,
-  420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482,
-  475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309,
-  305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271, 268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428,
-  424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315,
-  312, 310, 307, 304, 302, 299, 297, 294, 292, 289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259,
-];
-
-const shgTable: i32[] = [
-  9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-  19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-  22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-  23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
-  24, 24, 24,
-];
-
-let stackPool: StackBlurNode[] = [];
-
-// @ts-ignore: decorator
-@inline
-function initializeStackPool(radius: i32): void {
-  if (stackPool.length === 0) {
-    let div: i32 = radius + radius + 1;
-    for (let i = 0; i < div; i++) {
-      stackPool.push(new StackBlurNode());
-    }
-  }
-}
-
-// @ts-ignore: decorator
-@inline
-function clamp(value: i32): u8 {
-  return <u8>(value < 0 ? 0 : value > 255 ? 255 : value);
-}
-
-// @ts-ignore: decorator
-@inline
-function clamp3(value: i32, min: i32, max: i32): i32 {
-  if (value < min) return min;
-  if (value > max) return max;
-  return value;
-}
-
-// @ts-ignore: decorator
-@inline
-function clampSIMD(value: v128): v128 {
-  let clamped = i32x4.max_s(value, CLAMP_MIN);
-  clamped = i32x4.min_s(clamped, CLAMP_MAX);
-  return clamped;
-}
-
-// @ts-ignore: decorator
-@inline
-function boxBlur(image: Uint8Array, width: i32, height: i32, blurRadius: i32, output: Uint8Array): Uint8Array {
-  if (blurRadius < 1) return image;
-
-  const diameter: i32 = blurRadius * 2 + 1;
-  const divisor: i32 = diameter;
-
-  // Temporäres Array für den horizontalen Blur
-  let tempOutput = new Uint8Array(image.length);
-
-  // Horizontaler Blur
-  for (let y: i32 = 0; y < height; y++) {
-    let sum: i32 = 0;
-    // Initialer Summe für das erste Fenster
-    for (let i: i32 = -blurRadius; i <= blurRadius; i++) {
-      let x = clamp3(i, 0, width - 1);
-      sum += image[y * width + x];
-    }
-
-    // Erste Pixel im horizontalen Blur
-    tempOutput[y * width] = <u8>(sum / divisor);
-
-    // Bewegen des Fensters über die Zeile
-    for (let x: i32 = 1; x < width; x++) {
-      let removeIdx = x - blurRadius - 1;
-      let addIdx = x + blurRadius;
-
-      removeIdx = clamp3(removeIdx, 0, width - 1);
-      addIdx = clamp3(addIdx, 0, width - 1);
-
-      sum = sum - image[y * width + removeIdx] + image[y * width + addIdx];
-      tempOutput[y * width + x] = <u8>(sum / divisor);
-    }
-  }
-
-  // Vertikaler Blur mit SIMD
-  for (let x: i32 = 0; x < width; x++) {
-    let sum: i32 = 0;
-    // Initiale Summe für das erste Fenster
-    for (let i: i32 = -blurRadius; i <= blurRadius; i++) {
-      let y = clamp3(i, 0, height - 1);
-      sum += tempOutput[y * width + x];
-    }
-
-    // Erste Pixel im vertikalen Blur
-    output[x] = <u8>(sum / divisor);
-
-    // Bewegen des Fensters über die Spalte
-    for (let y: i32 = 1; y < height; y++) {
-      let removeIdx = y - blurRadius - 1;
-      let addIdx = y + blurRadius;
-
-      removeIdx = clamp3(removeIdx, 0, height - 1);
-      addIdx = clamp3(addIdx, 0, height - 1);
-
-      sum = sum - tempOutput[removeIdx * width + x] + tempOutput[addIdx * width + x];
-      output[y * width + x] = <u8>(sum / divisor);
-    }
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function stackBlur(image: Uint8Array, width: i32, height: i32, radius: i32, output: Uint8Array): Uint8Array {
-  if (radius < 1) return image;
-
-  initializeStackPool(radius);
-
-  let div: i32 = radius + radius + 1;
-  let widthMinus1: i32 = width - 1;
-  let heightMinus1: i32 = height - 1;
-  let radiusPlus1: i32 = radius + 1;
-  let sumFactor: i32 = (radiusPlus1 * (radiusPlus1 + 1)) / 2;
-
-  let stackStart: StackBlurNode = stackPool[0];
-  let stack: StackBlurNode = stackStart;
-  let stackEnd: StackBlurNode | null = null;
-
-  for (let i: i32 = 1; i < div; i++) {
-    stack.next = stackPool[i];
-    stack = stack.next!;
-    if (i == radiusPlus1) stackEnd = stack;
-  }
-
-  stack.next = stackStart;
-  let stackIn: StackBlurNode;
-  let stackOut: StackBlurNode;
-
-  let mulSum: i32 = mulTable[radius];
-  let shgSum: i32 = shgTable[radius];
-
-  let yi: i32 = 0;
-  let sum: i32;
-  let outSum: i32, inSum: i32;
-
-  // Horizontal blur
-  for (let y: i32 = 0; y < height; y++) {
-    inSum = sum = 0;
-    outSum = radiusPlus1 * image[yi];
-    sum += sumFactor * image[yi];
-    stack = stackStart;
-
-    for (let i: i32 = 0; i < radiusPlus1; i++) {
-      stack.value = image[yi];
-      stack = stack.next!;
-    }
-
-    for (let i: i32 = 1; i < radiusPlus1; i++) {
-      let p = yi + (i <= widthMinus1 ? i : widthMinus1);
-      stack.value = image[p];
-
-      let rbs: i32 = radiusPlus1 - i;
-      sum += stack.value * rbs;
-      inSum += stack.value;
-      stack = stack.next!;
-    }
-
-    stackIn = stackStart;
-    stackOut = stackEnd!;
-
-    for (let x: i32 = 0; x < width; x++) {
-      output[yi + x] = (sum * mulSum) >> shgSum;
-
-      sum -= outSum;
-      outSum -= stackIn.value;
-
-      let p = yi + (x + radius <= widthMinus1 ? x + radius : widthMinus1);
-      stackIn.value = image[p];
-
-      inSum += stackIn.value;
-      sum += inSum;
-      stackIn = stackIn.next!;
-      outSum += stackOut.value;
-      inSum -= stackOut.value;
-      stackOut = stackOut.next!;
-    }
-    yi += width;
-  }
-
-  // Vertical blur
-  for (let x: i32 = 0; x < width; x++) {
-    inSum = sum = 0;
-    outSum = radiusPlus1 * output[x];
-    sum += sumFactor * output[x];
-    stack = stackStart;
-
-    for (let i: i32 = 0; i < radiusPlus1; i++) {
-      stack.value = output[x];
-      stack = stack.next!;
-    }
-
-    for (let i: i32 = 1; i <= radius; i++) {
-      let p = x + (i < heightMinus1 ? i : heightMinus1) * width;
-      stack.value = output[p];
-
-      let rbs: i32 = radiusPlus1 - i;
-      sum += stack.value * rbs;
-      inSum += stack.value;
-      stack = stack.next!;
-    }
-
-    stackIn = stackStart;
-    stackOut = stackEnd!;
-
-    for (let y: i32 = 0; y < height; y++) {
-      let p = y * width + x;
-      image[p] = (sum * mulSum) >> shgSum;
-
-      sum -= outSum;
-      outSum -= stackIn.value;
-
-      let pp = x + (y + radius < heightMinus1 ? (y + radius) * width : heightMinus1 * width);
-      stackIn.value = output[pp];
-      inSum += stackIn.value;
-      sum += inSum;
-      stackIn = stackIn.next!;
-      outSum += stackOut.value;
-      inSum -= stackOut.value;
-      stackOut = stackOut.next!;
-    }
-  }
-
-  return image;
-}
-
-// @ts-ignore: decorator
-@inline
-function cropImage(image: Uint8Array, inputWidth: i32, inputHeight: i32, channels: i32, top: i32, left: i32, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const rowSize = width * channels;
-  const simdWidth = 16; // Process 16 bytes at a time
-
-  for (let y = 0; y < height; y++) {
-    const srcOffset = ((top + y) * inputWidth + left) * channels;
-    const dstOffset = y * rowSize;
-    let x = 0;
-
-    // SIMD loop
-    for (; x <= rowSize - simdWidth; x += simdWidth) {
-      const srcPtr = changetype<usize>(image.buffer) + srcOffset + x;
-      const dstPtr = changetype<usize>(output.buffer) + dstOffset + x;
-
-      // Load 16 bytes from source
-      const pixelData = v128.load(srcPtr);
-
-      // Store 16 bytes to destination
-      v128.store(dstPtr, pixelData);
-    }
-
-    // Handle remaining pixels
-    for (; x < rowSize; x++) {
-      output[dstOffset + x] = image[srcOffset + x];
-    }
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function resizeImageNearestNeighbor(
-  image: Uint8Array,
-  inputWidth: i32,
-  inputHeight: i32,
-  channels: i32,
-  outputWidth: i32,
-  outputHeight: i32,
-  output: Uint8Array,
-): Uint8Array {
-  const xRatio = (((inputWidth - 1) as f64) / outputWidth) as f64;
-  const yRatio = (((inputHeight - 1) as f64) / outputHeight) as f64;
-
-  const channelCount = channels;
-  const simdWidth = 16 / channelCount; // Process 16 bytes at a time
-
-  for (let y = 0; y < outputHeight; y++) {
-    const srcY = <i32>Math.min(Math.floor((y as f64) * yRatio), inputHeight - 1);
-    const dstY = y * outputWidth * channelCount;
-    let x = 0;
-
-    // SIMD loop
-    for (; x <= outputWidth - simdWidth; x += simdWidth) {
-      const srcX = <i32>Math.min(Math.floor((x as f64) * xRatio), inputWidth - simdWidth);
-      const dstIdx = dstY + x * channelCount;
-      const srcIdx = (srcY * inputWidth + srcX) * channelCount;
-
-      // Check if we can use SIMD for the next 16 bytes
-      if (srcIdx + 16 <= image.length && dstIdx + 16 <= output.length) {
-        // Load 16 bytes from source
-        const pixelData = v128.load(changetype<usize>(image.buffer) + <usize>srcIdx);
-
-        // Store 16 bytes to destination
-        v128.store(changetype<usize>(output.buffer) + <usize>dstIdx, pixelData);
-      } else {
-        // Fallback to scalar processing
-        for (let i = 0; i < simdWidth; i++) {
-          const srcXI = <i32>Math.min(Math.floor(((x + i) as f64) * xRatio), inputWidth - 1);
-          const dstIdxI = dstY + (x + i) * channelCount;
-          const srcIdxI = (srcY * inputWidth + srcXI) * channelCount;
-
-          for (let c = 0; c < channelCount; c++) {
-            output[dstIdxI + c] = image[srcIdxI + c];
-          }
-        }
-      }
-    }
-
-    // Handle remaining pixels
-    for (; x < outputWidth; x++) {
-      const srcX = <i32>Math.min(Math.floor((x as f64) * xRatio), inputWidth - 1);
-      const dstIdx = dstY + x * channelCount;
-      const srcIdx = (srcY * inputWidth + srcX) * channelCount;
-
-      for (let c = 0; c < channelCount; c++) {
-        output[dstIdx + c] = image[srcIdx + c];
-      }
-    }
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertFormat(input: Uint8Array, width: i32, height: i32, inputChannels: i32, outputFormat: i32, output: Uint8Array): Uint8Array {
-  if (inputChannels == 1 && outputFormat == WASMImageFormat.RGB) {
-    return convertGrayscaleToRGB(input, width, height, output);
-  } else if (inputChannels == 1 && outputFormat == WASMImageFormat.RGBA) {
-    return convertGrayscaleToRGBA(input, width, height, output);
-  } else if (inputChannels == 3 && outputFormat == WASMImageFormat.GRAY) {
-    return convertRGBToGrayscale(input, width, height, output);
-  } else if (inputChannels == 3 && outputFormat == WASMImageFormat.RGBA) {
-    return convertRGBToRGBA(input, width, height, output);
-  } else if (inputChannels == 4 && outputFormat == WASMImageFormat.GRAY) {
-    return convertRGBAToGrayscale(input, width, height, output);
-  } else if (inputChannels == 4 && outputFormat == WASMImageFormat.RGB) {
-    return convertRGBAToRGB(input, width, height, output);
-  }
-  return input;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertYUVToGrayscale(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const frameSize = width * height;
-  const yPtr = changetype<usize>(image.buffer);
-  const outputPtr = changetype<usize>(output.buffer);
-
-  // Copy the Y plane directly as the grayscale image
-  memory.copy(outputPtr, yPtr, frameSize);
-
-  return output;
-}
-
-// @ts-ignore: decorator
-function convertYUVToRGB(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const frameSize = width * height;
-  const chromaSize = (width >> 1) * (height >> 1);
-
-  const yPtr = changetype<usize>(image.buffer);
-  const uPtr = yPtr + frameSize;
-  const vPtr = uPtr + chromaSize;
-
-  const outputPtr = changetype<usize>(output.buffer);
-
-  for (let j = 0; j < height; j++) {
-    const yRowOffset = j * width;
-    const uvRowOffset = (j >> 1) * (width >> 1);
-
-    for (let i = 0; i < width; i += 4) {
-      // Load U and V values for four pixels
-      const uvIndex1 = uvRowOffset + (i >> 1);
-      const u1 = load<u8>(uPtr + uvIndex1);
-      const v1 = load<u8>(vPtr + uvIndex1);
-
-      const uvIndex2 = uvRowOffset + ((i + 2) >> 1);
-      const u2 = load<u8>(uPtr + uvIndex2);
-      const v2 = load<u8>(vPtr + uvIndex2);
-
-      // Load Y values for four pixels
-      const y1 = load<u8>(yPtr + yRowOffset + i);
-      const y2 = load<u8>(yPtr + yRowOffset + i + 1);
-      const y3 = load<u8>(yPtr + yRowOffset + i + 2);
-      const y4 = load<u8>(yPtr + yRowOffset + i + 3);
-
-      let yVec = i32x4((y1 as i32) + -16, (y2 as i32) + -16, (y3 as i32) + -16, (y4 as i32) + -16);
-
-      let uVec = i32x4((u1 as i32) - 128, (u1 as i32) - 128, (u2 as i32) - 128, (u2 as i32) - 128);
-
-      let vVec = i32x4((v1 as i32) - 128, (v1 as i32) - 128, (v2 as i32) - 128, (v2 as i32) - 128);
-
-      let yScaled = i32x4.mul(yVec, Y_MULTIPLIER);
-
-      // R = (yScaled + 409 * vScaled + 128) >> 8
-      let r = i32x4.add(i32x4.add(yScaled, i32x4.mul(vVec, R_ADD)), v128.splat<i32>(128));
-      r = i32x4.shr_s(r, SHIFT);
-      r = clampSIMD(r);
-
-      // G = (yScaled - 100 * uScaled - 208 * vScaled + 128) >> 8
-      let g = i32x4.add(i32x4.add(yScaled, i32x4.mul(uVec, G_ADD1)), i32x4.mul(vVec, G_ADD2));
-      g = i32x4.add(g, v128.splat<i32>(128));
-      g = i32x4.shr_s(g, SHIFT);
-      g = clampSIMD(g);
-
-      // B = (yScaled + 516 * uScaled + 128) >> 8
-      let b = i32x4.add(i32x4.add(yScaled, i32x4.mul(uVec, B_ADD)), v128.splat<i32>(128));
-      b = i32x4.shr_s(b, SHIFT);
-      b = clampSIMD(b);
-
-      // Extract R values
-      let r0 = i32x4.extract_lane(r, 0) as u8;
-      let r1 = i32x4.extract_lane(r, 1) as u8;
-      let r2 = i32x4.extract_lane(r, 2) as u8;
-      let r3 = i32x4.extract_lane(r, 3) as u8;
-
-      // Extract G values
-      let g0 = i32x4.extract_lane(g, 0) as u8;
-      let g1 = i32x4.extract_lane(g, 1) as u8;
-      let g2 = i32x4.extract_lane(g, 2) as u8;
-      let g3 = i32x4.extract_lane(g, 3) as u8;
-
-      // Extract B values
-      let b0 = i32x4.extract_lane(b, 0) as u8;
-      let b1 = i32x4.extract_lane(b, 1) as u8;
-      let b2 = i32x4.extract_lane(b, 2) as u8;
-      let b3 = i32x4.extract_lane(b, 3) as u8;
-
-      // Calculate output indices
-      let outIndex1 = (yRowOffset + i) * 3;
-      let outIndex2 = (yRowOffset + i + 1) * 3;
-      let outIndex3 = (yRowOffset + i + 2) * 3;
-      let outIndex4 = (yRowOffset + i + 3) * 3;
-
-      // Store RGB values
-      store<u8>(outputPtr + outIndex1, r0);
-      store<u8>(outputPtr + outIndex1 + 1, g0);
-      store<u8>(outputPtr + outIndex1 + 2, b0);
-
-      store<u8>(outputPtr + outIndex2, r1);
-      store<u8>(outputPtr + outIndex2 + 1, g1);
-      store<u8>(outputPtr + outIndex2 + 2, b1);
-
-      store<u8>(outputPtr + outIndex3, r2);
-      store<u8>(outputPtr + outIndex3 + 1, g2);
-      store<u8>(outputPtr + outIndex3 + 2, b2);
-
-      store<u8>(outputPtr + outIndex4, r3);
-      store<u8>(outputPtr + outIndex4 + 1, g3);
-      store<u8>(outputPtr + outIndex4 + 2, b3);
-    }
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertYUVToRGBA(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const frameSize = width * height;
-  const chromaSize = (width >> 1) * (height >> 1);
-
-  const yPtr = changetype<usize>(image.buffer);
-  const uPtr = yPtr + frameSize;
-  const vPtr = uPtr + chromaSize;
-
-  let yIndex = 0;
-  let uvIndex = 0;
-  let outputIndex = 0;
-
-  for (let j = 0; j < height; j++) {
-    uvIndex = (j >> 1) * (width >> 1);
-    for (let i = 0; i < width; i++) {
-      const y = <i32>load<u8>(yPtr + yIndex++) - 16;
-      const u = <i32>load<u8>(uPtr + uvIndex) - 128;
-      const v = <i32>load<u8>(vPtr + uvIndex) - 128;
-
-      if ((i & 1) == 1) {
-        uvIndex++;
-      }
-
-      const c = y * 298;
-      const d = u * 516;
-      const e = v * 409;
-      const f = u * 100;
-      const g = v * 208;
-
-      const r = (c + e) >> 8;
-      const gVal = (c - f - g) >> 8;
-      const b = (c + d) >> 8;
-
-      store<u8>(changetype<usize>(output.buffer) + outputIndex++, clamp(r));
-      store<u8>(changetype<usize>(output.buffer) + outputIndex++, clamp(gVal));
-      store<u8>(changetype<usize>(output.buffer) + outputIndex++, clamp(b));
-      store<u8>(changetype<usize>(output.buffer) + outputIndex++, 255);
-    }
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertRGBToYUV(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const frameSize = width * height;
-  const chromaWidth = width >> 1;
-  const chromaHeight = height >> 1;
-  const chromaSize = chromaWidth * chromaHeight;
-
-  const yPtr = changetype<usize>(output.buffer);
-  const uPtr = yPtr + frameSize;
-  const vPtr = uPtr + chromaSize;
-
-  let yIndex: i32 = 0;
-  let uvIndex: i32 = 0;
-
-  // Compute Y values for each pixel
-  for (let j = 0; j < height; j++) {
-    for (let i = 0; i < width; i++) {
-      const rgbIndex = (j * width + i) * 3;
-      const R = image[rgbIndex];
-      const G = image[rgbIndex + 1];
-      const B = image[rgbIndex + 2];
-
-      // Calculate Y component
-      const Y = ((66 * R + 129 * G + 25 * B + 128) >> 8) + 16;
-      store<u8>(yPtr + yIndex++, clamp(Y));
-    }
-  }
-
-  // Compute U and V values by averaging over 2x2 blocks
-  for (let j = 0; j < height; j += 2) {
-    for (let i = 0; i < width; i += 2) {
-      let sumU: i32 = 0;
-      let sumV: i32 = 0;
-
-      // Sum U and V values in the 2x2 block
-      for (let yOffset = 0; yOffset < 2; yOffset++) {
-        for (let xOffset = 0; xOffset < 2; xOffset++) {
-          const x = i + xOffset;
-          const y = j + yOffset;
-
-          if (x >= width || y >= height) {
-            continue;
-          }
-
-          const rgbIndex = (y * width + x) * 3;
-          const R = image[rgbIndex];
-          const G = image[rgbIndex + 1];
-          const B = image[rgbIndex + 2];
-
-          // Calculate U and V components
-          const U = ((-38 * R - 74 * G + 112 * B + 128) >> 8) + 128;
-          const V = ((112 * R - 94 * G - 18 * B + 128) >> 8) + 128;
-
-          sumU += U;
-          sumV += V;
-        }
-      }
-
-      // Average U and V values and store them
-      const avgU = (sumU + 2) >> 2;
-      const avgV = (sumV + 2) >> 2;
-
-      store<u8>(uPtr + uvIndex, clamp(avgU));
-      store<u8>(vPtr + uvIndex, clamp(avgV));
-
-      uvIndex++;
-    }
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertRGBToGrayscale(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const numPixels = width * height;
-
-  for (let i = 0; i < numPixels; i++) {
-    const idx = i * 3;
-    const r = image[idx];
-    const g = image[idx + 1];
-    const b = image[idx + 2];
-    output[i] = ((r * 19595 + g * 38469 + b * 7472) >> 16) as u8;
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertRGBAToGrayscale(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const numPixels = width * height;
-
-  for (let i = 0; i < numPixels; i++) {
-    const idx = i * 4;
-    const r = image[idx];
-    const g = image[idx + 1];
-    const b = image[idx + 2];
-    output[i] = ((r * 19595 + g * 38469 + b * 7472) >> 16) as u8;
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertGrayscaleToRGB(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const numPixels = width * height;
-  let i: i32 = 0;
-  const simdWidth = 16; // Process 16 bytes at a time
-
-  // SIMD shuffle masks
-  const shuffleMask1 = i8x16(0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5);
-  const shuffleMask2 = i8x16(5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10);
-  const shuffleMask3 = i8x16(10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15, 15, 15);
-
-  while (i <= numPixels - simdWidth) {
-    // Load 16 bytes of grayscale values
-    const grayPtr = changetype<usize>(image.buffer) + i;
-    const grayVec = v128.load(grayPtr);
-
-    // Swizzle the grayscale values to RGB
-    const rgbVec1 = v128.swizzle(grayVec, shuffleMask1);
-    const rgbVec2 = v128.swizzle(grayVec, shuffleMask2);
-    const rgbVec3 = v128.swizzle(grayVec, shuffleMask3);
-
-    // Store the RGB values
-    const outputPtr = changetype<usize>(output.buffer) + i * 3;
-    v128.store(outputPtr, rgbVec1);
-    v128.store(outputPtr + 16, rgbVec2);
-    v128.store(outputPtr + 32, rgbVec3);
-
-    i += simdWidth;
-  }
-
-  // Handle remaining pixels
-  for (; i < numPixels; i++) {
-    const gray = image[i];
-    const idx = i * 3;
-    output[idx] = gray;
-    output[idx + 1] = gray;
-    output[idx + 2] = gray;
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertGrayscaleToRGBA(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const numPixels = width * height;
-  let i: i32 = 0;
-  const simdWidth = 4; // Process 4 pixels at a time for simplicity
-
-  // SIMD shuffle mask
-  const shuffleMask = i8x16(0, 0, 0, -1, 1, 1, 1, -1, 2, 2, 2, -1, 3, 3, 3, -1);
-
-  // Alpha value vector (255 only in alpha positions)
-  const alphaVec = i8x16(0, 0, 0, <i8>255, 0, 0, 0, <i8>255, 0, 0, 0, <i8>255, 0, 0, 0, <i8>255);
-
-  while (i <= numPixels - simdWidth) {
-    // Load 4 bytes of grayscale values
-    const grayPtr = changetype<usize>(image.buffer) + i;
-    const grayVec = v128.load(grayPtr);
-
-    // Swizzle the grayscale values to RGB and add alpha
-    const rgbaVec = v128.or(i8x16.swizzle(grayVec, shuffleMask), alphaVec);
-
-    // Store the RGBA values
-    const outputPtr = changetype<usize>(output.buffer) + i * 4;
-    v128.store(outputPtr, rgbaVec);
-
-    i += simdWidth;
-  }
-
-  // Handle remaining pixels
-  for (; i < numPixels; i++) {
-    const gray = image[i];
-    const idx = i * 4;
-    output[idx] = gray;
-    output[idx + 1] = gray;
-    output[idx + 2] = gray;
-    output[idx + 3] = 255; // Alpha channel
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertRGBToRGBA(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const numPixels = width * height;
-  let i: i32 = 0;
-  const simdWidth = 4; // Process 4 RGB pixels at a time
-
-  // SIMD shuffle mask
-  const shuffleMask = i8x16(0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11, -1);
-
-  // Alpha value vector (255 only in alpha positions)
-  const alphaVec = i8x16(0, 0, 0, <i8>255, 0, 0, 0, <i8>255, 0, 0, 0, <i8>255, 0, 0, 0, <i8>255);
-
-  while (i <= numPixels - simdWidth) {
-    // Load 12 bytes of RGB values (4 pixels)
-    const rgbPtr = changetype<usize>(image.buffer) + i * 3;
-    const rgbVec = v128.load(rgbPtr);
-
-    // Swizzle the RGB values to RGBA
-    const rgbaVec = v128.or(i8x16.swizzle(rgbVec, shuffleMask), alphaVec);
-
-    // Store the RGBA values
-    const outputPtr = changetype<usize>(output.buffer) + i * 4;
-    v128.store(outputPtr, rgbaVec);
-
-    i += simdWidth;
-  }
-
-  // Handle remaining pixels
-  for (; i < numPixels; i++) {
-    const idxRGB = i * 3;
-    const idxRGBA = i * 4;
-    output[idxRGBA] = image[idxRGB];
-    output[idxRGBA + 1] = image[idxRGB + 1];
-    output[idxRGBA + 2] = image[idxRGB + 2];
-    output[idxRGBA + 3] = 255; // Alpha channel
-  }
-
-  return output;
-}
-
-// @ts-ignore: decorator
-@inline
-function convertRGBAToRGB(image: Uint8Array, width: i32, height: i32, output: Uint8Array): Uint8Array {
-  const numPixels = width * height;
-
-  for (let i = 0; i < numPixels; i++) {
-    const idxRGBA = i * 4;
-    const idxRGB = i * 3;
-    output[idxRGB] = image[idxRGBA]; // R
-    output[idxRGB + 1] = image[idxRGBA + 1]; // G
-    output[idxRGB + 2] = image[idxRGBA + 2]; // B
-  }
-
-  return output;
-}
-
-export function processImage(
-  inputFrame: Uint8Array,
-  inputWidth: i32,
-  inputHeight: i32,
-  format: i32, // WASMImageFormat
-  cropTop: i32, // -1 if not cropping
-  cropLeft: i32,
-  cropWidth: i32,
-  cropHeight: i32,
-  resizeWidth: i32, // -1 if not resizing
-  resizeHeight: i32,
-  blurRadius: i32,
-  inputFormat: i32, // WASMInputFormat
-  reconvertYUV: i32, // 1 if reconvert YUV to RGB, 0 otherwise
-): Uint8Array {
-  let outputPtr: Uint8Array = inputFrame;
-  let width = inputWidth;
-  let height = inputHeight;
-  let channels: i32 = inputFormat == WASMInputFormat.YUV ? 1 : inputFormat == WASMInputFormat.RGB ? 3 : inputFormat == WASMInputFormat.RGBA ? 4 : 1;
-
-  let tempOutput: Uint8Array | null = null;
-
-  let reconvertRGBToYUV = false;
-  let reconvertRGBToRGBA = false;
-
-  // YUV conversion
-  if (inputFormat == WASMInputFormat.YUV) {
-    const frameSize = width * height;
-    const outputChannels = format == WASMImageFormat.GRAY ? 1 : format == WASMImageFormat.RGB ? 3 : 4;
-    tempOutput = new Uint8Array(frameSize * outputChannels);
-
-    if (format == WASMImageFormat.GRAY) {
-      outputPtr = convertYUVToGrayscale(outputPtr, width, height, tempOutput);
-      channels = 1;
-    } else if (format == WASMImageFormat.RGB || format == WASMImageFormat.RGBA) {
-      outputPtr = convertYUVToRGB(outputPtr, width, height, tempOutput);
-      channels = 3;
-
-      if (format == WASMImageFormat.RGBA) {
-        reconvertRGBToRGBA = true;
-      }
-    }
-    // else if (format == WASMImageFormat.RGBA) {
-    //   outputPtr = convertYUVToRGBA(outputPtr, width, height, tempOutput);
-    //   channels = 4;
-    // }
-    else {
-      outputPtr = convertYUVToRGB(outputPtr, width, height, tempOutput);
-      channels = 3;
-      reconvertRGBToYUV = true;
-    }
-  }
-
-  // Cropping
-  if (cropWidth > 0 && cropHeight > 0) {
-    tempOutput = new Uint8Array(cropWidth * cropHeight * channels);
-    outputPtr = cropImage(outputPtr, width, height, channels, cropTop, cropLeft, cropWidth, cropHeight, tempOutput);
-    width = cropWidth;
-    height = cropHeight;
-  }
-
-  // Resizing
-  if (resizeWidth > 0 && resizeHeight > 0) {
-    tempOutput = new Uint8Array(resizeWidth * resizeHeight * channels);
-    outputPtr = resizeImageNearestNeighbor(outputPtr, width, height, channels, resizeWidth, resizeHeight, tempOutput);
-    width = resizeWidth;
-    height = resizeHeight;
-  }
-
-  // Blur
-  if (blurRadius > 0) {
-    tempOutput = new Uint8Array(width * height * channels);
-    outputPtr = stackBlur(outputPtr, width, height, blurRadius, tempOutput);
-  }
-
-  // Format conversion for non-YUV inputs
-  if (inputFormat != WASMInputFormat.YUV && format != inputFormat) {
-    tempOutput = new Uint8Array(width * height * (format == WASMImageFormat.RGBA ? 4 : format == WASMImageFormat.RGB ? 3 : 1));
-    outputPtr = convertFormat(outputPtr, width, height, channels, format, tempOutput);
-    channels = format == WASMImageFormat.RGBA ? 4 : format == WASMImageFormat.RGB ? 3 : 1;
-  }
-
-  // Reconversion to YUV
-  if (reconvertRGBToYUV && reconvertYUV == 1) {
-    tempOutput = new Uint8Array(width * height * 2);
-    outputPtr = convertRGBToYUV(outputPtr, width, height, tempOutput);
-  }
-
-  // Reconversion to RGBA
-  if (reconvertRGBToRGBA) {
-    tempOutput = new Uint8Array(width * height * 4);
-    outputPtr = convertRGBToRGBA(outputPtr, width, height, tempOutput);
-  }
-
-  return outputPtr;
-}
-
-export const Uint8Array_ID = idof<Uint8Array>();