Formato BC7

Il formato BC7 è un formato di compressione texture utilizzato per la compressione di dati RGB e RGBA di alta qualità.

Per informazioni sulle modalità di blocco del formato BC7, vedere Riferimento alle Modalità del Formato BC7.

Informazioni su BC7/DXGI_FORMAT_BC7

BC7 viene specificato dai valori di enumerazione DXGI_FORMAT seguenti:

• DXGI_FORMAT_BC7_TYPELESS.
• DXGI_FORMAT_BC7_UNORM.
• DXGI_FORMAT_BC7_UNORM_SRGB.

Il formato BC7 può essere usato per Texture2D (incluse matrici), Texture3D o TextureCube (incluse le matrici). Analogamente, questo formato si applica a qualsiasi superficie della mappa MIP associata a queste risorse.

BC7 usa una dimensione di blocco fissa di 16 byte (128 bit) e una dimensione di riquadro fissa di 4x4 texel. Come con i formati BC precedenti, le immagini di trama maggiori delle dimensioni del riquadro supportate (4x4) vengono compresse usando più blocchi. Questa identità di indirizzamento si applica anche a immagini tridimensionali e mappe MIP, mappe cubi e matrici di trame. Tutti i riquadri immagine devono essere dello stesso formato.

BC7 comprime sia immagini di dati a tre canali (RGB) che a quattro canali (RGBA) a virgola fissa. In genere, i dati di origine sono a 8 bit per ogni componente colore (canale), anche se il formato è in grado di codificare i dati di origine con bit più elevati per ogni componente colore. Tutti i riquadri immagine devono essere dello stesso formato.

Il decodificatore BC7 esegue la decompressione prima dell'applicazione del filtro delle trame.

L'hardware di decompressione BC7 deve essere accurato; ovvero, l'hardware deve restituire risultati identici ai risultati restituiti dal decodificatore descritto in questo documento.

implementazione BC7

Un'implementazione BC7 può specificare una delle 8 modalità, dove la modalità è specificata nel bit meno significativo del blocco da 16 byte (128 bit). La modalità è codificata da zero o più bit con un valore pari a 0 seguito da 1.

Un blocco BC7 può contenere più coppie di endpoint. Il set di indici che corrispondono a una coppia di endpoint può essere definito "subset". In alcune modalità di blocco, inoltre, la rappresentazione dell'endpoint viene codificata in un modulo che può essere definito "RBGP", in cui il bit "P" rappresenta un bit condiviso meno significativo per i componenti di colore dell'endpoint. Ad esempio, se la rappresentazione dell'endpoint per il formato è "RGB 5.5.5.1", l'endpoint viene interpretato come un valore RGB 6.6.6, dove lo stato del bit P definisce il bit meno significativo di ogni componente. Analogamente, per i dati di origine con un canale alfa, se la rappresentazione per il formato è "RGBAP 5.5.5.5.1", l'endpoint viene interpretato come RGBA 6.6.6.6. A seconda della modalità di blocco, è possibile specificare il bit condiviso meno significativo per entrambi gli endpoint di un subset singolarmente (2 P-bit per subset) o condivisi tra endpoint di un subset (1 P-bit per subset).

Per i blocchi BC7 che non codificano in modo esplicito il componente alfa, un blocco BC7 è costituito da bit di modalità, bit di partizione, endpoint compressi, indici compressi e un bit P facoltativo. In questi blocchi gli endpoint hanno una rappresentazione solo RGB e il componente alfa viene decodificato come 1.0 per tutti i texel nei dati di origine.

Per i blocchi BC7 con componenti di colore e alfa combinati, un blocco è costituito da bit di modalità, endpoint compressi, indici compressi e bit di partizione facoltativi e un bit P opzionale. In questi blocchi, i colori dell'endpoint sono espressi in formato RGBA e i valori dei componenti alfa vengono interpolati insieme ai valori dei componenti colore.

Per i blocchi BC7 con componenti di colore e alfa separati, un blocco consiste di bit di modalità, bit di rotazione, endpoint compressi, indici compressi e un bit facoltativo di selettore di indice. Questi blocchi hanno un vettore RGB efficace [R, G, B] e un canale alfa scalare [A] codificato separatamente.

Nella tabella seguente sono elencati i componenti di ogni tipo di blocco.

Il blocco BC7 contiene...	bit di modalità	bit di rotazione	bit del selettore di indice	bit di partizione	endpoint compresso	P-bit	indici compressi
solo componenti di colore	Obbligatorio	Non disponibile	Non disponibile	Obbligatorio	Obbligatorio	opzionale	Obbligatorio
colore + alfa combinato	Obbligatorio	Non disponibile	Non disponibile	opzionale	Obbligatorio	opzionale	Obbligatorio
colore e alfa separati	Obbligatorio	Obbligatorio	opzionale	Non disponibile	Obbligatorio	Non disponibile	Obbligatorio

 

BC7 definisce una palette di colori lungo una linea approssimativa tra due endpoint. Il valore della modalità determina il numero di coppie di endpoint interpolati per blocco. BC7 archivia un indice della palette per texel.

Per ogni subset di indici che corrisponde a una coppia di endpoint, il codificatore corregge lo stato di un bit dei dati dell'indice compresso per tale subset. Ciò avviene scegliendo un ordine degli endpoint che consenta all'indice designato di correzione di impostare il proprio bit più significativo su 0, che può essere quindi scartato, risparmiando un bit per ogni sottoinsieme. Per le modalità di blocco con un solo subset, l'indice di correzione è sempre lo 0.

Decodifica del formato BC7

Il seguente pseudocodice descrive i passaggi per decomprimere il pixel alla posizione (x,y) in base al blocco BC7 a 16 byte.

decompress_bc7(x, y, block)
{
    mode = extract_mode(block);
    
    //decode partition data from explicit partition bits
    subset_index = 0;
    num_subsets = 1;
    
    if (mode.type == 0 OR == 1 OR == 2 OR == 3 OR == 7)
    {
        num_subsets = get_num_subsets(mode.type);
        partition_set_id = extract_partition_set_id(mode, block);
        subset_index = get_partition_index(num_subsets, partition_set_id, x, y);
    }
    
    //extract raw, compressed endpoint bits
    UINT8 endpoint_array[num_subsets][4] = extract_endpoints(mode, block);
    
    //decode endpoint color and alpha for each subset
    fully_decode_endpoints(endpoint_array, mode, block);
    
    //endpoints are now complete.
    UINT8 endpoint_start[4] = endpoint_array[2 * subset_index];
    UINT8 endpoint_end[4]   = endpoint_array[2 * subset_index + 1];
        
    //Determine the palette index for this pixel
    alpha_index     = get_alpha_index(block, mode, x, y);
    alpha_bitcount  = get_alpha_bitcount(block, mode);
    color_index     = get_color_index(block, mode, x, y);
    color_bitcount  = get_color_bitcount(block, mode);

    //determine output
    UINT8 output[4];
    output.rgb = interpolate(endpoint_start.rgb, endpoint_end.rgb, color_index, color_bitcount);
    output.a   = interpolate(endpoint_start.a,   endpoint_end.a,   alpha_index, alpha_bitcount);
    
    if (mode.type == 4 OR == 5)
    {
        //Decode the 2 color rotation bits as follows:
        // 00 – Block format is Scalar(A) Vector(RGB) - no swapping
        // 01 – Block format is Scalar(R) Vector(AGB) - swap A and R
        // 10 – Block format is Scalar(G) Vector(RAB) - swap A and G
        // 11 - Block format is Scalar(B) Vector(RGA) - swap A and B
        rotation = extract_rot_bits(mode, block);
        output = swap_channels(output, rotation);
    }
    
}

Lo pseudocodice seguente descrive i passaggi per decodificare completamente il colore dell'endpoint e i componenti alfa per ogni subset dato un blocco BC7 a 16 byte.

fully_decode_endpoints(endpoint_array, mode, block)
{
    //first handle modes that have P-bits
    if (mode.type == 0 OR == 1 OR == 3 OR == 6 OR == 7)
    {
        for each endpoint i
        {
            //component-wise left-shift
            endpoint_array[i].rgba = endpoint_array[i].rgba << 1;
        }
        
        //if P-bit is shared
        if (mode.type == 1) 
        {
            pbit_zero = extract_pbit_zero(mode, block);
            pbit_one = extract_pbit_one(mode, block);
            
            //rgb component-wise insert pbits
            endpoint_array[0].rgb |= pbit_zero;
            endpoint_array[1].rgb |= pbit_zero;
            endpoint_array[2].rgb |= pbit_one;
            endpoint_array[3].rgb |= pbit_one;  
        }
        else //unique P-bit per endpoint
        {  
            pbit_array = extract_pbit_array(mode, block);
            for each endpoint i
            {
                endpoint_array[i].rgba |= pbit_array[i];
            }
        }
    }

    for each endpoint i
    {
        // Color_component_precision & alpha_component_precision includes pbit
        // left shift endpoint components so that their MSB lies in bit 7
        endpoint_array[i].rgb = endpoint_array[i].rgb << (8 - color_component_precision(mode));
        endpoint_array[i].a = endpoint_array[i].a << (8 - alpha_component_precision(mode));

        // Replicate each component's MSB into the LSBs revealed by the left-shift operation above
        endpoint_array[i].rgb = endpoint_array[i].rgb | (endpoint_array[i].rgb >> color_component_precision(mode));
        endpoint_array[i].a = endpoint_array[i].a | (endpoint_array[i].a >> alpha_component_precision(mode));
    }
        
    //If this mode does not explicitly define the alpha component
    //set alpha equal to 1.0
    if (mode.type == 0 OR == 1 OR == 2 OR == 3)
    {
        for each endpoint i
        {
            endpoint_array[i].a = 255; //i.e. alpha = 1.0f
        }
    }
}

Per generare ogni componente interpolato per ogni subset, usare l'algoritmo seguente: lasciare che "c" sia il componente da generare; lasciare che "e0" sia il componente dell'endpoint 0 del subset; e lasciare che "e1" sia il componente dell'endpoint 1 del subset.

UINT16 aWeight2[] = {0, 21, 43, 64};
UINT16 aWeight3[] = {0, 9, 18, 27, 37, 46, 55, 64};
UINT16 aWeight4[] = {0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64};

UINT8 interpolate(UINT8 e0, UINT8 e1, UINT8 index, UINT8 indexprecision)
{
    if(indexprecision == 2)
        return (UINT8) (((64 - aWeights2[index])*UINT16(e0) + aWeights2[index]*UINT16(e1) + 32) >> 6);
    else if(indexprecision == 3)
        return (UINT8) (((64 - aWeights3[index])*UINT16(e0) + aWeights3[index]*UINT16(e1) + 32) >> 6);
    else // indexprecision == 4
        return (UINT8) (((64 - aWeights4[index])*UINT16(e0) + aWeights4[index]*UINT16(e1) + 32) >> 6);
}

Lo pseudocodice seguente illustra come estrarre indici e conteggi dei bit per i componenti di colore e alfa. I blocchi con colore separato e alfa hanno anche due set di dati di indice: uno per il canale vettoriale e uno per il canale scalare. Per la modalità 4, questi indici presentano larghezze diverse (2 o 3 bit) e un selettore a un bit che specifica se i dati vettoriali o scalari usano gli indici a 3 bit. L'estrazione del numero di bit alfa è simile all'estrazione del numero di bit di colore, ma con comportamento inverso basato sul idxMode bit.

bitcount get_color_bitcount(block, mode)
{
    if (mode.type == 0 OR == 1)
        return 3;
    
    if (mode.type == 2 OR == 3 OR == 5 OR == 7)
        return 2;
    
    if (mode.type == 6)
        return 4;
        
    //The only remaining case is Mode 4 with 1-bit index selector
    idxMode = extract_idxMode(block);
    if (idxMode == 0)
        return 2;
    else
        return 3;
}

Informazioni di riferimento sulla modalità formato BC7

Questa sezione contiene un elenco delle 8 modalità di blocco e delle allocazioni di bit per i blocchi del formato di compressione texture BC7.

I colori per ogni subset all'interno di un blocco sono rappresentati da due colori di endpoint espliciti e da un set di colori interpolati tra di essi. A seconda della precisione dell'indice del blocco, ogni subset può avere 4, 8 o 16 colori possibili.

Modalità 0

La modalità BC7 0 presenta le caratteristiche seguenti:

• Solo componenti colore (nessun alfa)
• 3 sottogruppi per blocco
• Gli endpoint RGBP 4.4.4.1 con un P-bit univoco per ciascun endpoint
• Indici a 3 bit
• 16 partizioni

modalità 1

La modalità BC7 1 presenta le caratteristiche seguenti:

• Solo componenti colore (nessun alfa)
• 2 subset per blocco
• Endpoint RGBP 6.6.6.1 con un P-bit condiviso per sottoinsieme)
• Indici a 3 bit
• 64 partizioni

Modalità 2

La modalità BC7 2 presenta le caratteristiche seguenti:

• Solo componenti colore (nessun alfa)
• 3 sottogruppi per blocco
• Endpoint RGB 5.5.5
• Indici a 2 bit
• 64 partizioni

layout a 2 bit

modalità 3

La modalità BC7 3 presenta le caratteristiche seguenti:

• Solo componenti colore (nessun alfa)
• 2 subset per blocco
• Endpoint RGBP 7.7.7.1 con un bit P univoco per sottogruppo
• Indici a 2 bit
• 64 partizioni

Modalità 4

La modalità BC7 4 presenta le caratteristiche seguenti:

• Componenti dei colori con componente alfa separato
• 1 subset per blocco
• Endpoint di colori RGB 5.5.5
• Endpoint alfa a 6 bit
• Indici a 16 x 2 bit
• Indici a 16 x 3 bit
• Rotazione dei componenti a 2 bit
• Selettore di indice a 1 bit (se vengono usati gli indici a 2 o 3 bit)

Modalità 5

La modalità BC7 5 presenta le caratteristiche seguenti:

• Componenti dei colori con componente alfa separato
• 1 subset per blocco
• Punti di estremità del colore RGB 7.7.7
• Endpoint alfa a 6 bit
• Indici di colore a 16 x 2 bit
• Indici alfa 16 x 2 bit
• Rotazione dei componenti a 2 bit

modalità 6

La modalità BC7 6 presenta le caratteristiche seguenti:

• Colori combinati e componenti alfa
• Un subset per blocco
• Endpoint colore (e alfa) RGBAP 7.7.7.7.1 (P-bit unico per punto finale)
• Indici a 16 x 4 bit

Modalità 7

La modalità BC7 7 presenta le caratteristiche seguenti:

• Colori combinati e componenti alfa
• 2 subset per blocco
• Endpoint colore RGBAP 5.5.5.5.1 (e alfa) (P-bit univoco per endpoint)
• Indici a 2 bit
• 64 partizioni

Notazioni

La modalità 8 (il byte meno significativo è impostato su 0x00) è riservata. Non usarlo nel codificatore. Se si trasmette questa modalità all'hardware, viene restituito un blocco inizializzato a tutti gli zeri.

In BC7 è possibile codificare il componente alfa in uno dei modi seguenti:

• Tipi di blocco senza codifica esplicita dei componenti alfa. In questi blocchi, gli endpoint di colore hanno una codifica solo RGB, con il componente alfa decodificato a 1.0 per tutti i texel.

• Tipi di blocchi con componenti di colore e alfa combinati. In questi blocchi, i valori dei colori dell'endpoint vengono specificati nel formato RGBA e i valori dei componenti alfa vengono interpolati insieme ai valori di colore.

• Tipi di blocchi con componenti alfa e colore separati. In questi blocchi i valori di colore e alfa vengono specificati separatamente, ognuno con il proprio set di indici. Di conseguenza, hanno un vettore efficace e un canale scalare codificato separatamente, dove il vettore specifica comunemente i canali di colore [R, G, B] e il canale scalare specifica il canale alfa [A]. Per supportare questo approccio, viene fornito un campo a 2 bit separato nella codifica, che consente la specifica della codifica del canale separata come valore scalare. Di conseguenza, il blocco può avere una delle quattro rappresentazioni seguenti di questa codifica alfa (come indicato dal campo a 2 bit):

  • RGB|A: canale alfa separato
  • AGB |R: canale di colore "rosso" separato
  • RAB |G: canale di colore "verde" separato
  • RGB |B: canale di colore "blu" separato

  Il decodificatore riordina l'ordine del canale a RGBA dopo la decodifica, quindi il formato del blocco interno è invisibile allo sviluppatore. I colori neri aventi componenti di colore e alfa separati possiedono anche due set di dati di indice: uno per l'insieme vettoriale di canali e uno per il canale scalare. Nel caso della modalità 4, questi indici hanno larghezze diverse [2 o 3 bit]. La modalità 4 contiene anche un selettore a 1 bit che specifica se il vettore o il canale scalare usa gli indici a 3 bit.

Argomenti correlati

Compressione dei blocchi di texture