New swizzle functions

hw/xbox/swizzle.c

@@ -22,71 +22,122 @@
 
 #include <stdint.h>
 #include <string.h>
+#include <assert.h>
 #include "qemu/osdep.h"
 
 #include "hw/xbox/swizzle.h"
 
-static unsigned int log2i(unsigned int i)
+/* This should be pretty straightforward.
+ * It creates a bit pattern like ..zyxzyxzyx from ..xxx, ..yyy and ..zzz
+ * If there are no bits left from any component it will pack the other masks
+ * more tighly (Example: zzxzxzyx = Fewer x than z and even fewer y)
+ */
+static void generate_swizzle_masks(unsigned int width,
+                                   unsigned int height,
+                                   unsigned int depth,
+                                   uint32_t* mask_x,
+                                   uint32_t* mask_y,
+                                   uint32_t* mask_z)
 {
-    unsigned int r = 0;
-    while (i >>= 1) r++;
-    return r;
+    uint32_t x = 0, y = 0, z = 0;
+    uint32_t bit = 1;
+    uint32_t mask_bit = 1;
+    bool done;
+    do {
+        done = true;
+        if (bit < width) { x |= mask_bit; mask_bit <<= 1; done = false; }
+        if (bit < height) { y |= mask_bit; mask_bit <<= 1; done = false; }
+        if (bit < depth) { z |= mask_bit; mask_bit <<= 1; done = false; }
+        bit <<= 1;
+    } while(!done);
+    assert(x ^ y ^ z == (mask_bit - 1));
+    *mask_x = x;
+    *mask_y = y;
+    *mask_z = z;
+}
+
+/* This fills a pattern with a value if your value has bits abcd and your
+ * pattern is 11010100100 this will return: 0a0b0c00d00
+ */
+static uint32_t fill_pattern(uint32_t pattern, uint32_t value)
+{
+    uint32_t result = 0;
+    uint32_t bit = 1;
+    while(value) {
+        if (pattern & bit) {
+            /* Copy bit to result */
+            result |= value & 1 ? bit : 0;
+            value >>= 1;
+        }
+        bit <<= 1;
+    }
+    return result;
 }
 
 static unsigned int get_swizzled_offset(
-    unsigned int x, unsigned int y,
-    unsigned int width, unsigned int height,
+    unsigned int x, unsigned int y, unsigned int z,
+    uint32_t mask_x, uint32_t mask_y, uint32_t mask_z,
     unsigned int bytes_per_pixel)
 {
-    unsigned int k = log2i(MIN(width, height));
-
-    unsigned int u = (x & 0x001) << 0 |
-        (x & 0x002) << 1 |
-        (x & 0x004) << 2 |
-        (x & 0x008) << 3 |
-        (x & 0x010) << 4 |
-        (x & 0x020) << 5 |
-        (x & 0x040) << 6 |
-        (x & 0x080) << 7 |
-        (x & 0x100) << 8 |
-        (x & 0x200) << 9 |
-        (x & 0x400) << 10 |
-        (x & 0x800) << 11;
-
-    unsigned int v = (y & 0x001) << 1 |
-        (y & 0x002) << 2 |
-        (y & 0x004) << 3 |
-        (y & 0x008) << 4 |
-        (y & 0x010) << 5 |
-        (y & 0x020) << 6 |
-        (y & 0x040) << 7 |
-        (y & 0x080) << 8 |
-        (y & 0x100) << 9 |
-        (y & 0x200) << 10 |
-        (y & 0x400) << 11 |
-        (y & 0x800) << 12;
-
-    return bytes_per_pixel * (((u | v) & ~(~0 << 2*k)) |
-             (x & (~0 << k)) << k |
-             (y & (~0 << k)) << k);
+    return bytes_per_pixel * (fill_pattern(mask_x, x)
+                           | fill_pattern(mask_y, y)
+                           | fill_pattern(mask_z, z));
 }
 
-void swizzle_rect(
+void swizzle_box(
     const uint8_t *src_buf,
     unsigned int width,
     unsigned int height,
+    unsigned int depth,
     uint8_t *dst_buf,
-    unsigned int pitch,
+    unsigned int row_pitch,
+    unsigned int slice_pitch,
     unsigned int bytes_per_pixel)
 {
-    int x, y;
-    for (y = 0; y < height; y++) {
-        for (x = 0; x < width; x++) {
-            const uint8_t *src = src_buf+ (y * pitch + x * bytes_per_pixel);
-            uint8_t *dst = dst_buf +
-                get_swizzled_offset(x, y, width, height, bytes_per_pixel);
-            memcpy(dst, src, bytes_per_pixel);
+    uint32_t mask_x, mask_y, mask_z;
+    generate_swizzle_masks(width, height, depth, &mask_x, &mask_y, &mask_z);
+
+    int x, y, z;
+    for (z = 0; z < depth; z++) {
+        for (y = 0; y < height; y++) {
+            for (x = 0; x < width; x++) {
+                const uint8_t *src = src_buf
+                                         + y * row_pitch + x * bytes_per_pixel;
+                uint8_t *dst = dst_buf + get_swizzled_offset(x, y, 0,
+                                                             mask_x, mask_y, 0,
+                                                             bytes_per_pixel);
+                memcpy(dst, src, bytes_per_pixel);
+            }
         }
+        src_buf += slice_pitch;
+    }
+}
+
+void unswizzle_box(
+    const uint8_t *src_buf,
+    unsigned int width,
+    unsigned int height,
+    unsigned int depth,
+    uint8_t *dst_buf,
+    unsigned int row_pitch,
+    unsigned int slice_pitch,
+    unsigned int bytes_per_pixel)
+{
+    uint32_t mask_x, mask_y, mask_z;
+    generate_swizzle_masks(width, height, depth, &mask_x, &mask_y, &mask_z);
+
+    int x, y, z;
+    for (z = 0; z < depth; z++) {
+        for (y = 0; y < height; y++) {
+            for (x = 0; x < width; x++) {
+                const uint8_t *src = src_buf
+                    + get_swizzled_offset(x, y, z, mask_x, mask_y, mask_z,
+                                          bytes_per_pixel);
+                uint8_t *dst = dst_buf + y * row_pitch + x * bytes_per_pixel;
+                memcpy(dst, src, bytes_per_pixel);
+            }
+        }
+        dst_buf += slice_pitch;
     }
 }
 
@@ -98,13 +149,16 @@ void unswizzle_rect(
     unsigned int pitch,
     unsigned int bytes_per_pixel)
 {
-    int x, y;
-    for (y = 0; y < height; y++) {
-        for (x = 0; x < width; x++) {
-            const uint8_t *src = src_buf
-                + get_swizzled_offset(x, y, width, height, bytes_per_pixel);
-            uint8_t *dst = dst_buf + (y * pitch + x * bytes_per_pixel);
-            memcpy(dst, src, bytes_per_pixel);
-        }
-    }
-}
+    unswizzle_box(src_buf, width, height, 1, dst_buf, pitch, 0, bytes_per_pixel);
+}
+
+void swizzle_rect(
+    const uint8_t *src_buf,
+    unsigned int width,
+    unsigned int height,
+    uint8_t *dst_buf,
+    unsigned int pitch,
+    unsigned int bytes_per_pixel)
+{
+    swizzle_box(src_buf, width, height, 1, dst_buf, pitch, 0, bytes_per_pixel);
+}

hw/xbox/swizzle.h

@@ -22,6 +22,34 @@
 #ifndef HW_XBOX_SWIZZLE_H
 #define HW_XBOX_SWIZZLE_H
 
+void swizzle_box(
+    const uint8_t *src_buf,
+    unsigned int width,
+    unsigned int height,
+    unsigned int depth,
+    uint8_t *dst_buf,
+    unsigned int row_pitch,
+    unsigned int slice_pitch,
+    unsigned int bytes_per_pixel);
+
+void unswizzle_box(
+    const uint8_t *src_buf,
+    unsigned int width,
+    unsigned int height,
+    unsigned int depth,
+    uint8_t *dst_buf,
+    unsigned int row_pitch,
+    unsigned int slice_pitch,
+    unsigned int bytes_per_pixel);
+
+void unswizzle_rect(
+    const uint8_t *src_buf,
+    unsigned int width,
+    unsigned int height,
+    uint8_t *dst_buf,
+    unsigned int pitch,
+    unsigned int bytes_per_pixel);
+
 void swizzle_rect(
     const uint8_t *src_buf,
     unsigned int width,
@@ -30,12 +58,4 @@ void swizzle_rect(
     unsigned int pitch,
     unsigned int bytes_per_pixel);
 
- void unswizzle_rect(
-    const uint8_t *src_buf,
-    unsigned int width,
-    unsigned int height,
-    uint8_t *dst_buf,
-    unsigned int pitch,
-    unsigned int bytes_per_pixel);
-
-#endif
+#endif