@onekeyfe/hd-core 1.2.0-alpha.167 → 1.2.0-alpha.169

package/src/utils/pro2Wallpaper.ts

@@ -6,12 +6,26 @@ import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 export const PRO2_WALLPAPER_WIDTH = 604;
 export const PRO2_WALLPAPER_HEIGHT = 1024;
 
-export type Pro2WallpaperColorFormat = 'RGB565' | 'RGB565A8';
+export type Pro2WallpaperColorFormat = 'RGB565' | 'RGB565A8' | 'I8';
+
+export type Pro2WallpaperEncoding = 'rgb565' | 'i8-lz4';
 
 export type Pro2ImageAlphaMode = 'preserve' | 'black-background';
 
 const COLOR_FORMAT_RGB565 = 0x12;
 const COLOR_FORMAT_RGB565A8 = 0x14;
+const COLOR_FORMAT_I8 = 0x0a;
+const IMAGE_FLAG_COMPRESSED = 0x0008;
+const IMAGE_COMPRESSION_LZ4 = 0x00000002;
+const I8_PALETTE_SIZE = 256 * 4;
+const I8_RED_LEVELS = 6;
+const I8_GREEN_LEVELS = 7;
+const I8_BLUE_LEVELS = 6;
+const LZ4_MIN_MATCH = 4;
+const LZ4_LAST_LITERALS = 5;
+const LZ4_MATCH_FIND_LIMIT = 12;
+const LZ4_HASH_BITS = 16;
+const LZ4_HASH_MULTIPLIER = -1640531535;
 
 const RED_THRESHOLD = [
   1, 7, 3, 5, 0, 8, 2, 6, 7, 1, 5, 3, 8, 0, 6, 2, 3, 5, 0, 8, 2, 6, 1, 7, 5, 3, 8, 0, 6, 2, 7, 1, 0,
@@ -38,6 +52,184 @@ function align(value: number, boundary: number): number {
   return Math.ceil(value / boundary) * boundary;
 }
 
+function writeLz4Length(output: Uint8Array, offset: number, length: number) {
+  let cursor = offset;
+  let remaining = length;
+  while (remaining >= 0xff) {
+    output[cursor] = 0xff;
+    cursor += 1;
+    remaining -= 0xff;
+  }
+  output[cursor] = remaining;
+  return cursor + 1;
+}
+
+function readUint32LittleEndian(data: Uint8Array, offset: number) {
+  return (
+    data[offset] | (data[offset + 1] << 8) | (data[offset + 2] << 16) | (data[offset + 3] << 24)
+  );
+}
+
+function getLz4Hash(sequence: number) {
+  return (Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_BITS)) & 0xffff;
+}
+
+function compressLz4Block(input: Uint8Array) {
+  const output = new Uint8Array(input.byteLength + Math.floor(input.byteLength / 0xff) + 16);
+  const hashTable = new Int32Array(1 << LZ4_HASH_BITS);
+  hashTable.fill(-1);
+
+  let anchor = 0;
+  let inputOffset = 0;
+  let outputOffset = 0;
+  const matchFindEnd = input.byteLength - LZ4_MATCH_FIND_LIMIT;
+  const matchCopyEnd = input.byteLength - LZ4_LAST_LITERALS;
+
+  while (inputOffset <= matchFindEnd) {
+    const sequence = readUint32LittleEndian(input, inputOffset);
+    const hash = getLz4Hash(sequence);
+    const reference = hashTable[hash];
+    hashTable[hash] = inputOffset;
+
+    const matchOffset = inputOffset - reference;
+    const hasMatch =
+      reference >= 0 &&
+      matchOffset <= 0xffff &&
+      readUint32LittleEndian(input, reference) === sequence;
+    if (hasMatch) {
+      let matchLength = LZ4_MIN_MATCH;
+      while (
+        inputOffset + matchLength < matchCopyEnd &&
+        input[reference + matchLength] === input[inputOffset + matchLength]
+      ) {
+        matchLength += 1;
+      }
+
+      const literalLength = inputOffset - anchor;
+      const encodedMatchLength = matchLength - LZ4_MIN_MATCH;
+      const tokenOffset = outputOffset;
+      outputOffset += 1;
+      output[tokenOffset] =
+        (Math.min(literalLength, 0x0f) << 4) | Math.min(encodedMatchLength, 0x0f);
+
+      if (literalLength >= 0x0f) {
+        outputOffset = writeLz4Length(output, outputOffset, literalLength - 0x0f);
+      }
+      output.set(input.subarray(anchor, inputOffset), outputOffset);
+      outputOffset += literalLength;
+
+      output[outputOffset] = matchOffset & 0xff;
+      output[outputOffset + 1] = matchOffset >> 8;
+      outputOffset += 2;
+      if (encodedMatchLength >= 0x0f) {
+        outputOffset = writeLz4Length(output, outputOffset, encodedMatchLength - 0x0f);
+      }
+
+      const matchStart = inputOffset;
+      inputOffset += matchLength;
+      anchor = inputOffset;
+      for (
+        let cursor = Math.max(matchStart + 1, inputOffset - 2);
+        cursor < inputOffset;
+        cursor += 1
+      ) {
+        if (cursor <= matchFindEnd) {
+          hashTable[getLz4Hash(readUint32LittleEndian(input, cursor))] = cursor;
+        }
+      }
+    } else {
+      inputOffset += 1;
+    }
+  }
+
+  const literalLength = input.byteLength - anchor;
+  const tokenOffset = outputOffset;
+  outputOffset += 1;
+  output[tokenOffset] = Math.min(literalLength, 0x0f) << 4;
+  if (literalLength >= 0x0f) {
+    outputOffset = writeLz4Length(output, outputOffset, literalLength - 0x0f);
+  }
+  output.set(input.subarray(anchor), outputOffset);
+  outputOffset += literalLength;
+
+  return output.slice(0, outputOffset);
+}
+
+function quantizeChannel(value: number, levels: number) {
+  return Math.floor((value * (levels - 1) + 0x7f) / 0xff);
+}
+
+function expandChannel(value: number, levels: number) {
+  return Math.floor((value * 0xff + Math.floor((levels - 1) / 2)) / (levels - 1));
+}
+
+function encodePro2I8Lz4(options: {
+  width: number;
+  height: number;
+  rgba: Uint8Array | ArrayBuffer;
+}): { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat } {
+  const { width, height } = options;
+  if (!Number.isInteger(width) || width <= 0 || width > 0xffff) {
+    throw invalidParameter('Wallpaper width must be an integer between 1 and 65535.');
+  }
+  if (!Number.isInteger(height) || height <= 0 || height > 0xffff) {
+    throw invalidParameter('Wallpaper height must be an integer between 1 and 65535.');
+  }
+  const rgba = asBytes(options.rgba);
+  const expectedLength = width * height * 4;
+  if (rgba.byteLength !== expectedLength) {
+    throw invalidParameter(
+      `Wallpaper RGBA data length must be ${expectedLength} bytes, received ${rgba.byteLength}.`
+    );
+  }
+  const stride = width;
+  const rawData = new Uint8Array(I8_PALETTE_SIZE + stride * height);
+
+  for (let red = 0; red < I8_RED_LEVELS; red += 1) {
+    for (let green = 0; green < I8_GREEN_LEVELS; green += 1) {
+      for (let blue = 0; blue < I8_BLUE_LEVELS; blue += 1) {
+        const paletteIndex = (red * I8_GREEN_LEVELS + green) * I8_BLUE_LEVELS + blue;
+        const paletteOffset = paletteIndex * 4;
+        // LVGL stores its ARGB8888 palette as B, G, R, A bytes on little-endian devices.
+        rawData[paletteOffset] = expandChannel(blue, I8_BLUE_LEVELS);
+        rawData[paletteOffset + 1] = expandChannel(green, I8_GREEN_LEVELS);
+        rawData[paletteOffset + 2] = expandChannel(red, I8_RED_LEVELS);
+        rawData[paletteOffset + 3] = 0xff;
+      }
+    }
+  }
+
+  for (let pixel = 0; pixel < width * height; pixel += 1) {
+    const sourceOffset = pixel * 4;
+    const alpha = rgba[sourceOffset + 3];
+    const red = Math.round((rgba[sourceOffset] * alpha) / 0xff);
+    const green = Math.round((rgba[sourceOffset + 1] * alpha) / 0xff);
+    const blue = Math.round((rgba[sourceOffset + 2] * alpha) / 0xff);
+    const paletteIndex =
+      (quantizeChannel(red, I8_RED_LEVELS) * I8_GREEN_LEVELS +
+        quantizeChannel(green, I8_GREEN_LEVELS)) *
+        I8_BLUE_LEVELS +
+      quantizeChannel(blue, I8_BLUE_LEVELS);
+    rawData[I8_PALETTE_SIZE + pixel] = paletteIndex;
+  }
+
+  const compressed = compressLz4Block(rawData);
+  const data = new Uint8Array(24 + compressed.byteLength);
+  const view = new DataView(data.buffer);
+  data[0] = 0x19;
+  data[1] = COLOR_FORMAT_I8;
+  view.setUint16(2, IMAGE_FLAG_COMPRESSED, true);
+  view.setUint16(4, width, true);
+  view.setUint16(6, height, true);
+  view.setUint16(8, stride, true);
+  view.setUint16(10, 0, true);
+  view.setUint32(12, IMAGE_COMPRESSION_LZ4, true);
+  view.setUint32(16, compressed.byteLength, true);
+  view.setUint32(20, rawData.byteLength, true);
+  data.set(compressed, 24);
+  return { data, colorFormat: 'I8' };
+}
+
 export function encodePro2Image(options: {
   width: number;
   height: number;
@@ -125,6 +317,10 @@ export function encodePro2Wallpaper(options: {
   width: number;
   height: number;
   rgba: Uint8Array | ArrayBuffer;
+  encoding?: Pro2WallpaperEncoding;
 }): { data: Uint8Array; colorFormat: Pro2WallpaperColorFormat } {
+  if (options.encoding === 'i8-lz4') {
+    return encodePro2I8Lz4(options);
+  }
   return encodePro2Image(options);
 }