Rapide de Conversion RGBA pour ARGB

Je suis en train de convertir un rgba tampon en argb, est-il possible d'améliorer l'algorithme suivant, ou tout autre moyen plus rapide pour effectuer une telle opération?
Tenant compte du fait que la valeur alpha n'est pas important une fois dans l'argb de la mémoire tampon, et doit toujours se terminer comme 0xFF.

int y, x, pixel;

for (y = 0; y < height; y++)
{
    for (x = 0; x < width; x++)
    {
     pixel = rgbaBuffer[y * width + x];
     argbBuffer[(height - y - 1) * width + x] = (pixel & 0xff00ff00) | ((pixel << 16) & 0x00ff0000) | ((pixel >> 16) & 0xff);
    }
}

InformationsquelleAutor PerracoLabs | 2012-06-29

4

Je vais me concentrer uniquement dans la fonction de permutation:
```
typedef unsigned int Color32;

inline Color32 Color32Reverse(Color32 x)
{

    return
    //Source is in format: 0xAARRGGBB
        ((x & 0xFF000000) >> 24) | //______AA
        ((x & 0x00FF0000) >>  8) | //____RR__
        ((x & 0x0000FF00) <<  8) | //__GG____
        ((x & 0x000000FF) << 24);  //BB______
    //Return value is in format:  0xBBGGRRAA
}
```
- La question était de savoir RGBA pour ARGB, pas ARGB pour BGRA.
- Je pourrais avoir à se rétracter depuis ARGB et RGBA sont apparemment dénuée de sens des mots. Cela ne semble pas correspondre à la question (il ne définit pas l'alpha à 0xff). en.wikipedia.org/wiki/RGBA_color_space#Representation
InformationsquelleAutor Enrique Nieloud
1

En supposant que le code n'est pas buggé (seulement inefficace), je peux deviner que tout ce que vous voulez faire est de swap à chaque seconde (paires de) octet (et bien sûr inverser le tampon), n'est-ce pas?

De sorte que vous pouvez obtenir quelques optimisations par:
- En évitant les maj et les opérations de masquage
- L'optimisation de la boucle, par exemple, économiser dans les calculs des indices de
Je voudrais réécrire le code comme suit:
```
int y, x;

for (y = 0; y < height; y++)
{
    unsigned char *pRGBA= (unsigned char *)(rgbaBuffer+y*width);
    unsigned char *pARGB= (unsigned char *)(argbBuffer+(height-y-1)*width);
    for (x = 4*(width-1); x>=0; x-=4)
    {
        pARGB[x  ]   = pRGBA[x+2];
        pARGB[x+1]   = pRGBA[x+1];
        pARGB[x+2]   = pRGBA[x  ];
        pARGB[x+3]   = 0xFF;
    }
}
```
Veuillez noter que le plus complexe des indices de calcul est effectué dans la boucle externe seulement. Il y a quatre acesses à la fois rgbaBuffer et argbBuffer pour chaque pixel, mais je pense que cela est plus que compensé par éviter les opérations au niveau du bit et de l'indixes calculs. Une autre solution serait (comme dans votre code) extraction/stockage d'un pixel (int) à la fois, et de faire le traitement sur place (ce econimizes dans l'accès à la mémoire), mais à moins d'avoir une méthode efficace pour permuter les deux octets et définir l'alpha localement (par exemple, certains assembly en ligne, afin que vous vous assurez que tout est effectué à des registres de niveau), il ne sera pas vraiment vous aider.

InformationsquelleAutor Constantine Georgiou
1

Code fourni est très étrange, car il mélange des composants de la couleur pas rgba->argb, mais rgba->rabg.

J'ai fait une exacte et la version optimisée de cette routine.
```
int pixel;
int size = width * height;

for (unsigned int * rgba_ptr = rgbaBuffer, * argb_ptr = argbBuffer + size - 1; argb_ptr >= argbBuffer; rgba_ptr++, argb_ptr--)
{
    //*argb_ptr = *rgba_ptr >> 8 | 0xff000000;  //- this version doesn't change endianess
    *argb_ptr = __builtin_bswap32(*rgba_ptr) >> 8 | 0xff000000;  //This does
}
```
La première chose que j'ai faite est de simplifier votre brassage de l'expression. Il est évident que XRGB est juste RGBA >> 8.
Aussi j'ai supprimé le calcul de l'index de tableau à chaque itération, et utilisé des pointeurs comme les variables de boucle.
Cette version est environ 2 fois plus rapide que l'original sur ma machine.

Vous pouvez également utiliser de l'ESS pour traînant si ce code est prévu pour les CPU x86.
- Même si cela semble être la manière la plus rapide de mise en œuvre, l'effectif des images s'affichent en rouge tonique, donc quelque chose qui est mauvais dans l'opération. J'ai besoin de mentionner que c'est pour les téléphones Android.
- Ahem, de prendre en accont l'endianess il semble que vous voulez convertir abgr->argb ie. vous voulez convertir rgba->argb et changement endianess à la fois. Suis-je la corriger?
- Aussi, avez-vous besoin pour inverser l'image à l'envers?
- J'ai besoin de convertir à partir rgba->argb, sans retourner l'image à l'envers. Tout le problème vient du fait que je suis en utilisant opengl glReadPixels(...) qui renvoie les données au format RGBA, et puis je dois le convertir en un compatible android bitmap qui nécessite l'ARGB. Et la conversion de RGBA pour ARGB doit être effectuée à la vitesse maximale possible. Il n'y a pas de solution de rechange à l'aide de la glReadPixels comme cadre de tampons pour le scénario, je travaille, donc je suis en train de presser un peu de vitesse à chaque algorithme
- Mais en regardant dans votre code, il existe un flip et endianess changement. J'ai aussi changé de code un peu, donc il va réorganiser composant dans votre code
InformationsquelleAutor Roman Zavalov

Utiliser de l'assemblée, ce qui suit est pour les processeurs Intel.

Cet exemple swaps de Rouge et de Bleu.

void* b = pixels;
UINT len = textureWidth*textureHeight;

__asm                                                       
{
    mov ecx, len                //Set loop counter to pixels memory block size
    mov ebx, b                  //Set ebx to pixels pointer
    label:                      
        mov al,[ebx+0]          //Load Red to al
        mov ah,[ebx+2]          //Load Blue to ah
        mov [ebx+0],ah          //Swap Red
        mov [ebx+2],al          //Swap Blue
        add ebx,4               //Move by 4 bytes to next pixel
        dec ecx                 //Decrease loop counter
        jnz label               //If not zero jump to label
}

C'est le cas où le faible niveau d'optimisation ne fonctionne pas. J'ai essayé de compiler quelques trivial de code C++ avec l'octet les changements et le compilateur optimisé le tout pour seulement bswap edi. Voir godbolt.org/g/hk2QiR

InformationsquelleAutor Elias

Vous devez vous connecter pour publier un commentaire.