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

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

@@ -0,0 +1,890 @@
+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>();