> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Formatos de embaralhamento do DirectStorage > Formatos de embaralhamento do DirectStorage A partir do GDK de março de 2024, há várias opções adicionais para o parâmetro de modo de swizzle na API DirectStorage do XBOX. Essas opções foram projetadas para proporcionar economia adicional no tamanho compactado quando usadas em conjunto com a compactação baseada em BCPACK ou ZLib. Cada um desses formatos de embaralhamento descreve uma reorganização dos dados quando armazenados em disco que pode gerar melhorias no tamanho compactado quando usada com o formato BCn pretendido. A opção de modo de swizzle no DirectStorage reorganiza os dados à medida que os grava na memória para prepará-los para uma correção final. Um sombreador de computação realiza uma correção final dos dados para restaurar a ordem correta dos bytes. O código de referência fornecido abaixo demonstra como preparar o formato em disco dos dados. Um sombreador de exemplo que pode realizar a "correção" final dos dados pode ser disponibilizado mediante solicitação. Entre em contato com seu representante da Microsoft se quiser uma cópia desses sombreadores. Embora a funcionalidade descrita abaixo funcione com quaisquer dados que atendam aos requisitos de alinhamento, ela se destina a conteúdo com swizzle offline e é mais eficaz quando combinada com ele. ## Conteúdo * [DSTORAGE\_SWIZZLE\_MODE\_4K\_4K\_8K](#DSTORAGE_SWIZZLE_MODE_4K_4K_8K) * [DSTORAGE\_SWIZZLE\_MODE\_4K\_12K\_4K\_4K\_8K](#DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K) * [DSTORAGE\_SWIZZLE\_MODE\_4K\_4K\_24K](#DSTORAGE_SWIZZLE_MODE_4K_4K_24K) * [DSTORAGE\_SWIZZLE\_MODE\_4K\_12K\_4K\_12K](#DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K) ## DSTORAGE\_SWIZZLE\_MODE\_4K\_4K\_8K Este modo destina-se ao uso com conteúdo codificado em BC1. O tamanho do conteúdo não compactado deve ser um múltiplo de 16 KB. Este modo pressupõe que os dados de origem estejam agrupados por fluxo (ou seja, pontos de extremidade e índices), o que melhora a compactabilidade. Os dados de origem também devem ser compactados usando Zlib ou BCPack. Quando DSTORAGE\_SWIZZLE\_MODE\_4K\_4K\_8K é fornecido para a opção DSTORAGE\_REQUEST\_OPTIONS::SwizzleMode, o DirectStorage reorganiza o conteúdo não compactado na memória em grupos intercalados de 16 KB, extraídos dos dados correspondentes no conteúdo agrupado. Cada grupo de 16 KB contém todos os dados do conteúdo BC1 original, embora ainda agrupados. O conteúdo original pode ser totalmente reconstruído no local a partir do grupo de 16 KB com um sombreador de computação. Diagrama das transformações de DSTORAGE_SWIZZLE_MODE_4K_4K_8K ```C++ theme={null} // 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 Este modo destina-se ao uso com conteúdo codificado em BC3. O tamanho do conteúdo não compactado deve ser um múltiplo de 32 KB. Este modo pressupõe que os dados de origem estejam agrupados por fluxo (ou seja, pontos de extremidade e índices), o que melhora a compactabilidade. Os dados de origem também devem ser compactados usando Zlib ou BCPack. Quando DSTORAGE\_SWIZZLE\_MODE\_4K\_12K\_4K\_4K\_8K é fornecido para a opção DSTORAGE\_REQUEST\_OPTIONS::SwizzleMode, o DirectStorage reorganiza o conteúdo não compactado na memória em grupos intercalados de 32 KB, extraídos dos dados correspondentes no conteúdo agrupado. Cada grupo de 32 KB contém todos os dados do conteúdo BC3 original, embora ainda agrupados. O conteúdo original pode ser totalmente reconstruído no local a partir do grupo de 32 KB com um sombreador de computação. Diagrama das transformações de DSTORAGE_SWIZZLE_MODE_4K_12K_4K_4K_8K ```C++ theme={null} // 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 Este modo destina-se ao uso com conteúdo codificado em BC4. O tamanho do conteúdo não compactado deve ser um múltiplo de 32 KB. Este modo pressupõe que os dados de origem estejam agrupados por fluxo (ou seja, pontos de extremidade e índices), o que melhora a compactabilidade. Os dados de origem também devem ser compactados usando Zlib ou BCPack. Quando DSTORAGE\_SWIZZLE\_MODE\_4K\_4K\_24K é fornecido para a opção DSTORAGE\_REQUEST\_OPTIONS::SwizzleMode, o DirectStorage reorganiza o conteúdo não compactado na memória em grupos intercalados de 32 KB, extraídos dos dados correspondentes no conteúdo agrupado. Cada grupo de 32 KB contém todos os dados do conteúdo BC4 original, embora ainda agrupados. O conteúdo original pode ser totalmente reconstruído no local a partir do grupo de 32 KB com um sombreador de computação. Diagrama das transformações de DSTORAGE_SWIZZLE_MODE_4K_4K_24K ```C++ theme={null} // 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 Este modo destina-se ao uso com conteúdo codificado em BC5. O tamanho do conteúdo não compactado deve ser um múltiplo de 32 KB. Este modo pressupõe que os dados de origem estejam agrupados por fluxo (ou seja, pontos de extremidade e índices), o que melhora a compactabilidade. Os dados de origem também devem ser compactados usando Zlib ou BCPack. Quando DSTORAGE\_SWIZZLE\_MODE\_4K\_12K\_4K\_12K é fornecido para a opção DSTORAGE\_REQUEST\_OPTIONS::SwizzleMode, o DirectStorage reorganiza o conteúdo não compactado na memória em grupos intercalados de 32 KB, extraídos dos dados correspondentes no conteúdo agrupado. Cada grupo de 32 KB contém todos os dados do conteúdo BC5 original, embora ainda agrupados. O conteúdo original pode ser totalmente reconstruído no local a partir do grupo de 32 KB com um sombreador de computação. Diagrama das transformações de DSTORAGE_SWIZZLE_MODE_4K_12K_4K_12K ```C++ theme={null} // 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); }; ``` ## Confira também [DirectStorage](/pt-BR/build/console-features/storage/directstorage-toc) [Uso e detalhes internos do DirectStorage](/pt-BR/build/console-features/storage/directstorage/directstorage-white-paper) [Analisando o desempenho do DirectStorage](/pt-BR/tools/tools-console/pix/pix-directstorage) [Lista de exemplos do GDK](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/development-downloads/gdk-samples-list) ## Related topics - [DirectStorage](/pt-BR/build/console-features/storage/directstorage-toc.md) - [Visão geral do DirectStorage](/pt-BR/build/console-features/storage/directstorage/directstorage-overview.md) - [Índice de tópicos sob NDA para desenvolvimento de console com o XBOX GDK](/pt-BR/nda/nda-overview.md) - [DStorage](/pt-BR/reference/system/dstorage/dstorage_members.md) - [IDStorageFactoryX](/pt-BR/reference/system/dstorage/interfaces/IDStorageFactoryX/idstoragefactoryx.md)