Difference between revisions of "ARZL"

Revision as of 21:33, 25 January 2022

LZRA (ARZL in big-endian) is a compression and encoding format used on PS Vita. It is used for example to store files used by the SKBL like the NSKBL and some Tzs modules. It is also used on GIM texture data used by /sce_sys/right/right.suprx.

Naming

It might be similar to LZMA. See [1].

There is a typo in SKBL functions names where it is named ARLZ instead of ARZL.

Header

ARZL header is simply the string "ARZL" (41 52 5A 4C).

Encoding

To encode data into ARZL: 1) Apply ARM filter. See #ARM Filter. 2) ARZL encode

Decoding

To decode ARZL data: 1) ARZL decode. See SKBL#sceArlzDecode. 2) Remove ARM filter. See #ARM Filter and SKBL#sceArlzArmFilter.

ARM Filter

ARZL encoded/decoded data is not the raw data but filtered data. It is applied an ARM filter for efficient compression, rather than obfuscation.

Although there are three versions of the ARM filters, the basic operation is the same. The filter is just bit swaps as well as some deterministic changes using information from the offset.

Version 0

int arzl_arm_filter_remove(unsigned char *buffer, int len) {
  unsigned char *buf, *bufend;
  uint32_t data;
  int change_stride;
  buf = buffer;
  bufend = &buffer[len];
  do {
    data = *(uint32_t *)buf;
    buf += 4;
    change_stride = (data & 0xF800F800) >> 27;
    if ((data & 0xF800F800) == 0xF800F000) {
      data = (((data >> 16) & 0xFFC007FF) | ((data & 0x7FF) << 11)) - ((buf - buffer) >> 1);
      *((uint32_t *)buf - 1) = ((((data & 0x7FF) << 16) | 0xF800F000) & 0xFFFFF800) | ((data >> 11) & 0x7FF);
    } else if (change_stride == 30)
      buf -= 2;
  } while (bufend > buf);
}

Version 1

ARM filter version 1 is the same as version 0 except that the offset information is added instead of subtracted.

data = (((data >> 16) & 0xFFC007FF) | ((data & 0x7FF) << 11)) + ((buf - buffer) >> 1);

Version 2

ARM filter version 2 is the same as version 0 but in addition, there is an additional operation to swap two nibbles in certain conditions. The condition is found through a learning process and may be overfitted.

else if ((data & 0x8000FBF0) == 0x0000F2C0) {
  data = (data & 0xF0FFFFF0) | ((data & 0xF) << 24) | ((data >> 24) & 0xF);
  *((uint32_t *)buf - 1) = data;
}

Tools

TODO

@@ Line 9: / Line 9: @@
 == Header ==
-It is simply the string "ARZL" (41 52 5A 4C).
+ARZL header is simply the string "ARZL" (41 52 5A 4C).
-== Obfuscation ==
+== Encoding ==
-This is actually an ARM Filter for efficient compression rather than obfuscation.
+To encode data into ARZL:
+) Apply ARM filter. See [[#ARM Filter]].
+) ARZL encode
-The raw decompressed ARZL output is obfuscated. Although there are three versions of the obfuscation, the basic operation is the same. The obfuscation is just bit swaps as well as some deterministic changes using information from the offset.
+== Decoding ==
+To decode ARZL data:
+) ARZL decode. See [[SKBL#sceArlzDecode]].
+) Remove ARM filter. See [[#ARM Filter]] and [[SKBL#sceArlzArmFilter]].
+== ARM Filter ==
+ARZL encoded/decoded data is not the raw data but filtered data. It is applied an ARM filter for efficient compression, rather than obfuscation.
+Although there are three versions of the ARM filters, the basic operation is the same. The filter is just bit swaps as well as some deterministic changes using information from the offset.
 === Version 0 ===
 <source lang="c">
-int arzl_deobfuscate(unsigned char *buffer, int len) {
+int arzl_arm_filter_remove(unsigned char *buffer, int len) {
    unsigned char *buf, *bufend;
    uint32_t data;
@@ Line 41: / Line 53: @@
 === Version 1 ===
-The only change is that the offset information is added instead of subtracted.
+ARM filter version 1 is the same as version 0 except that the offset information is added instead of subtracted.
 <source lang="c">
@@ Line 49: / Line 61: @@
 === Version 2 ===
-Version 2 is the same as version 0 but in addition, there is an additional operation to swap two nibbles in certain conditions. The condition is found through a learning process and may be overfitted.
+ARM filter version 2 is the same as version 0 but in addition, there is an additional operation to swap two nibbles in certain conditions. The condition is found through a learning process and may be overfitted.
 <source lang="c">
-      else if ((data & 0x8000FBF0) == 0x0000F2C0) {
+else if ((data & 0x8000FBF0) == 0x0000F2C0) {
-        data = (data & 0xF0FFFFF0) | ((data & 0xF) << 24) | ((data >> 24) & 0xF);
+  data = (data & 0xF0FFFFF0) | ((data & 0xF) << 24) | ((data >> 24) & 0xF);
-        *((uint32_t *)buf - 1) = data;
+  *((uint32_t *)buf - 1) = data;
-      }
+}
 </source>
+== Tools ==
+TODO
 [[Category:Formats]]