Pour convertir des données RGB 12 bits en données RGB 12 bits empaquetées

Question

J'ai quelques données RVB (image) de 12 bits. Chaque R, G, B a 12 bits, total 36 bits. Maintenant, je dois regrouper ces données RVB 12 bits dans un format de données compact. J'ai essayé de mentionner l'emballage comme suit: -

Actuellement j'ai des données d'entrée comme - B0 - 12 bits G0 - 12 bits R0 - 12 bits B1 - 12 bits G1 - 12 bits R1 - 12 bits .. bientôt. je besoin de le convertir en format compressé en: -

Byte1 - B8 (8 bits de données B0)

Byte2 - G4B4 (reste 4 bits de données B0 + 4 premiers bits de G0)

Byte3 - G8 (8 bits restants de G0)

Byte4 - R8 (8 premiers bits de R0)

Byte5 - B4R4 (4 premiers bits de B1 + 4 derniers bits du R0)

Je dois écrire ces octets individuels dans un fichier au format texte. un octet plus bas qu'un autre.

Une chose similaire que je dois faire pour une donnée d'entrée RGB 10 bits.

1. Y at-il un outil/logiciel pour obtenir la conversion des données que je cherche à faire. J'essaie de le faire dans un programme C - Je forme un 64 bits à partir des 12 bits individuels de R, G, B (36 bits au total). Mais après cela, je ne suis pas en mesure de trouver une logique pour choisir les bits nécessaires à partir d'un R, G, B données pour former un flux d'octets, et de les vider dans un fichier texte.

Des pointeurs seront utiles.

Answer 1

Utilisation bit à bit & (et), | (ou), et décalage < <, >> opérateurs.

Answer 2

Ceci est pratiquement non testé, code super malpropre que j'ai fouetté ensemble pour vous donner un début. Ce n'est probablement pas emballer les octets exactement comme vous voulez, mais vous devriez avoir l'idée générale. Désolé pour le code rapide et méchant, seulement eu quelques minutes, j'espère que c'est utile de toute façon.

#include <stdio.h> 

typedef struct 
{ 
    unsigned short B; 
    unsigned short G; 
    unsigned short R; 

} UnpackedRGB; 

UnpackedRGB test[] = 
{ 
    {0x0FFF, 0x000, 0x0EEE}, 
    {0x000, 0x0FEF, 0xDEF}, 
    {0xFED, 0xDED, 0xFED}, 
    {0x111, 0x222, 0x333}, 
    {0xA10, 0xB10, 0xC10} 
}; 

UnpackedRGB buffer = {0, 0, 0}; 

int main(int argc, char** argv) 
{ 
    int numSourcePixels = sizeof(test)/sizeof(UnpackedRGB); 

    /* round up to the last byte */ 
    int destbytes = ((numSourcePixels * 45)+5)/10; 

    unsigned char* dest = (unsigned char*)malloc(destbytes); 
    unsigned char* currentDestByte = dest; 

    UnpackedRGB *pixel1; 
    UnpackedRGB *pixel2; 
    int ixSource; 
    for (ixSource = 0; ixSource < numSourcePixels; ixSource += 2) 
    {  
     pixel1 = &test[ixSource]; 
     pixel2 = ((ixSource + 1) < numSourcePixels ? &test[ixSource] : &buffer); 

     *currentDestByte++ = (0x0FF) & pixel1->B; 
     *currentDestByte++ = ((0xF00 & pixel1->B) >> 8) | (0x0F & pixel1->G); 
     *currentDestByte++ = ((0xFF0 & pixel1->G) >> 4); 
     *currentDestByte++ = (0x0FF & pixel1->R); 
     *currentDestByte++ = ((0xF00 & pixel1->R) >> 8) | (0x0F & pixel2->B); 

     if ((ixSource + 1) >= numSourcePixels) 
     { 
      break; 
     } 

     *currentDestByte++ = ((0xFF0 & pixel2->B) >> 4); 
     *currentDestByte++ = (0x0FF & pixel2->G); 
     *currentDestByte++ = ((0xF00 & pixel2->G) >> 8) | (0x0F & pixel2->R); 
     *currentDestByte++ = (0xFF0 & pixel2->R); 
    } 

    FILE* outfile = fopen("output.bin", "w"); 
    fwrite(dest, 1, destbytes,outfile); 
    fclose(outfile); 
}