Formats de shuffle DirectStorage

À partir du GDK de mars 2024, plusieurs options supplémentaires sont disponibles pour le paramètre de mode de swizzle dans l’API DirectStorage XBOX. Ces options sont conçues pour réduire davantage la taille compressée lorsqu’elles sont utilisées conjointement avec une compression basée sur BCPACK ou ZLib. Chacun de ces formats de shuffle décrit un réarrangement des données lors de leur stockage sur disque, qui peut améliorer la taille compressée lorsqu’il est utilisé avec le format BCn prévu. L’option de mode de swizzle de DirectStorage réarrange les données à mesure qu’elle les écrit en mémoire afin de les préparer à une correction finale. Un compute shader effectue une correction finale des données pour restaurer l’ordre correct des octets. Le code de référence fourni ci-dessous montre comment préparer le format sur disque des données. Un exemple de shader capable d’effectuer la « correction » finale des données peut être mis à disposition sur demande. Contactez votre représentant Microsoft si vous souhaitez obtenir une copie de ces shaders.

Bien que la fonctionnalité décrite ci-dessous fonctionne avec toutes les données qui respectent les exigences d’alignement, elle est destinée au contenu swizzlé hors ligne et s’avère plus efficace lorsqu’elle est associée à celui-ci.

DSTORAGE_SWIZZLE_MODE_4K_4K_8K

Ce mode est destiné au contenu encodé en BC1. La taille du contenu non compressé doit être un multiple de 16 Ko. Ce mode suppose que les données sources sont regroupées par flux (c’est-à-dire points de terminaison et index), ce qui améliore la compressibilité. Les données sources doivent également être compressées avec Zlib ou BCPack. Lorsque DSTORAGE_SWIZZLE_MODE_4K_4K_8K est fourni pour l’option DSTORAGE_REQUEST_OPTIONS::SwizzleMode, DirectStorage réarrange le contenu non compressé en mémoire en groupes entrelacés de 16 Ko, à partir des données correspondantes du contenu regroupé. Chaque groupe de 16 Ko contient toutes les données du contenu BC1 d’origine, toujours regroupées. Le contenu d’origine peut être entièrement reconstruit sur place à partir du groupe de 16 Ko à l’aide d’un compute shader.

// 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);
};

DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K

Ce mode est destiné au contenu encodé en BC3. La taille du contenu non compressé doit être un multiple de 32 Ko. Ce mode suppose que les données sources sont regroupées par flux (c’est-à-dire points de terminaison et index), ce qui améliore la compressibilité. Les données sources doivent également être compressées avec Zlib ou BCPack. Lorsque DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K est fourni pour l’option DSTORAGE_REQUEST_OPTIONS::SwizzleMode, DirectStorage réarrange le contenu non compressé en mémoire en groupes entrelacés de 32 Ko, à partir des données correspondantes du contenu regroupé. Chaque groupe de 32 Ko contient toutes les données du contenu BC3 d’origine, toujours regroupées. Le contenu d’origine peut être entièrement reconstruit sur place à partir du groupe de 32 Ko à l’aide d’un compute shader.

// 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);
};

DSTORAGE_SWIZZLE_MODE_4K_4K_24K

Ce mode est destiné au contenu encodé en BC4. La taille du contenu non compressé doit être un multiple de 32 Ko. Ce mode suppose que les données sources sont regroupées par flux (c’est-à-dire points de terminaison et index), ce qui améliore la compressibilité. Les données sources doivent également être compressées avec Zlib ou BCPack. Lorsque DSTORAGE_SWIZZLE_MODE_4K_4K_24K est fourni pour l’option DSTORAGE_REQUEST_OPTIONS::SwizzleMode, DirectStorage réarrange le contenu non compressé en mémoire en groupes entrelacés de 32 Ko, à partir des données correspondantes du contenu regroupé. Chaque groupe de 32 Ko contient toutes les données du contenu BC4 d’origine, toujours regroupées. Le contenu d’origine peut être entièrement reconstruit sur place à partir du groupe de 32 Ko à l’aide d’un compute shader.

// 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);
};

DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K

Ce mode est destiné au contenu encodé en BC5. La taille du contenu non compressé doit être un multiple de 32 Ko. Ce mode suppose que les données sources sont regroupées par flux (c’est-à-dire points de terminaison et index), ce qui améliore la compressibilité. Les données sources doivent également être compressées avec Zlib ou BCPack. Lorsque DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K est fourni pour l’option DSTORAGE_REQUEST_OPTIONS::SwizzleMode, DirectStorage réarrange le contenu non compressé en mémoire en groupes entrelacés de 32 Ko, à partir des données correspondantes du contenu regroupé. Chaque groupe de 32 Ko contient toutes les données du contenu BC5 d’origine, toujours regroupées. Le contenu d’origine peut être entièrement reconstruit sur place à partir du groupe de 32 Ko à l’aide d’un compute shader.

// 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);
};

Voir aussi

DirectStorage Utilisation et détails internes de DirectStorage Analyse des performances de DirectStorage Liste des exemples du GDK

Introduction

Onboarding & Access

Setup & Install

Build Your First Title

Contenu

DSTORAGE_SWIZZLE_MODE_4K_4K_8K

DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K

DSTORAGE_SWIZZLE_MODE_4K_4K_24K

DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K

Voir aussi

​Contenu

​DSTORAGE_SWIZZLE_MODE_4K_4K_8K

​DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K

​DSTORAGE_SWIZZLE_MODE_4K_4K_24K

​DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K

​Voir aussi

Contenu

DSTORAGE_SWIZZLE_MODE_4K_4K_8K

DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K

DSTORAGE_SWIZZLE_MODE_4K_4K_24K

DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K

Voir aussi