DirectStorage 隨機排列格式

// This algorithm will rearrange a source buffer into the disk layout that works 
// with the DSTORAGE_SWIZZLE_MODE_4K_4K_8K swizzle mode.  The comments refer
// to an assumption that the source buffer is BC1 formatted data.
auto shuffle_224 = [](uint8_t* dest, const uint8_t* src, size_t size) {
    uint8_t* d1 = dest;            // e0
    uint8_t* d2 = dest + size / 4; // e1
    uint8_t* d3 = dest + size / 2; // indexes

    do {
        *d1++ = *src++; *d1++ = *src++; // e0 (2B)
        *d2++ = *src++; *d2++ = *src++; // e1 (2B)
        *d3++ = *src++; *d3++ = *src++; // ind (4B)
        *d3++ = *src++; *d3++ = *src++;
    } while (size -= 8);
};

// This algorithm will rearrange a source buffer into the disk layout that works 
// with the DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K swizzle mode.  The comments refer
// to an assumption that the source buffer is BC3 formatted data.
//
// NOTE: A0/A1 are interleaved 2K/2K in each 4KB range of that stream
auto shuffle_26_224 = [](uint8_t* dest, const uint8_t* src, size_t size) {
    uint8_t* d1 = dest, *d2 = dest + 2048;      // a0, a1 interleaved 2k/2k
    uint8_t* d3 = dest + size / 8;              // aind
    uint8_t* d4 = dest + size / 2;              // e0
    uint8_t *d5 = dest + size / 2 + size / 8;   // e1
    uint8_t* d6 = dest + size / 2 + size / 4;   // eind

    do {
        *d1++ = *src++;                                 // a0 (1B)
        *d2++ = *src++;                                 // a1 (1B)
        *d3++ = *src++; *d3++ = *src++; *d3++ = *src++; // aind (6B)
        *d3++ = *src++; *d3++ = *src++; *d3++ = *src++;
        *d4++ = *src++; *d4++ = *src++;                 // e0 (2B)
        *d5++ = *src++; *d5++ = *src++;                 // e1 (2B)
        *d6++ = *src++; *d6++ = *src++;                 // eind (4B)
        *d6++ = *src++; *d6++ = *src++;

        // every 2K tiles, we need to advance the interleave
        if ((size-16) % (2048*16) == 0)
        {
            d1 += 2048;
            d2 += 2048;
        }
    } while (size -= 16);
};

// This algorithm will rearrange a source buffer into the disk layout that works 
// with the DSTORAGE_SWIZZLE_MODE_4K_4K_24K swizzle mode.  The comments refer
// to an assumption that the source buffer is BC4 formatted data.
auto shuffle_116 = [](uint8_t* dest, const uint8_t* src, size_t size) {
    uint8_t* d1 = dest, *d2 = dest + size / 8;          // r0, r1
    uint8_t* d3 = dest + size / 4;                      // ind

    do {
        *d1++ = *src++;                                 // r0 (1B)
        *d2++ = *src++;                                 // r1 (1B)
        *d3++ = *src++; *d3++ = *src++; *d3++ = *src++; // ind (6B)
        *d3++ = *src++; *d3++ = *src++; *d3++ = *src++;
    } while (size -= 8);
};

// This algorithm will rearrange a source buffer into the disk layout that works 
// with the DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K swizzle mode.  The comments refer
// to an assumption that the source buffer is BC5 formatted data.
//
// NOTE: R0/R1 and G0/G1 are interleaved 2K/2K in each 4KB range of those streams
auto shuffle_26_26 = [](uint8_t* dest, const uint8_t* src, size_t size) {
    uint8_t* d1 = dest, *d2 = dest + 2048;                       // r0, r1 interleaved 2K/2K
    uint8_t* d3 = dest + size / 8;                               // rind
    uint8_t* d4 = dest + size / 2, *d5 = dest + size / 2 + 2048; // g0, g1 interleaved 2K/2K
    uint8_t* d6 = dest + size / 2 + size / 8;                    // gind

    do {
        *d1++ = *src++;                                 // r0 (1B)
        *d2++ = *src++;                                 // r1 (1B)
        *d3++ = *src++; *d3++ = *src++; *d3++ = *src++; // rind (6B)
        *d3++ = *src++; *d3++ = *src++; *d3++ = *src++;
        *d4++ = *src++;                                 // g0 (1B)
        *d5++ = *src++;                                 // g1 (1B)
        *d6++ = *src++; *d6++ = *src++; *d6++ = *src++; // gind (6B)
        *d6++ = *src++; *d6++ = *src++; *d6++ = *src++;

        // every 2K tiles, we need to advance the interleave
        if ((size - 16) % (2048 * 16) == 0)
        {
            d1 += 2048;
            d2 += 2048;
            d4 += 2048;
            d5 += 2048;
        }
    } while (size -= 16);
};