Optimisation et modification du codeC pour lire 4pixels au lieu 1

Signaler
Messages postés
4
Date d'inscription
vendredi 28 janvier 2005
Statut
Membre
Dernière intervention
12 mars 2005
-
Messages postés
571
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
5 décembre 2013
-
Bonjour,
j ai besoin de votre aide. J' ai reussi a optimiser mon code et de diminuer un peu le nombre de cycles lors de l execution. Ce code permet de lire les images et de les modifies en utilisant la methode ELA de-interlacing.

Maintenant, j ai une partie ou l image est traite pixel par pixel, j aimerai bien votre aide afin de la modifie et de la traite par 4 pixels.


/* img_out initialization */


img_out = (pix_type**)malloc(sizeof(pix_type*)*frame_height);


for(j=0; j T_d && D_d2 > T_d) dominant = true;


else dominant = false;


break;


case 1:


D_d1 = abs(dir_dif[1] - dir_dif[3]);


D_d2 = abs(dir_dif[1] - dir_dif[4]);


ptr_up = 1;


ptr_down = 3;


if(D_d1 > T_d && D_d2 > T_d) dominant = true;


else dominant = false;


break;


case 2:


ptr_up = 2;


ptr_down = 2;


dominant = false;


break;


case 3:


D_d1 = abs(dir_dif[3] - dir_dif[0]);


D_d2 = abs(dir_dif[3] - dir_dif[1]);


ptr_up = 3;


ptr_down = 1;


if(D_d1 > T_d && D_d2 > T_d) dominant = true;


else dominant = false;


break;


case 4:


D_d1 = abs(dir_dif[4] - dir_dif[0]);


D_d2 = abs(dir_dif[4] - dir_dif[1]);


ptr_up = 4;


ptr_down = 0;


if(D_d1 > T_d && D_d2 > T_d) dominant = true;


else dominant = false;


break;


default:


break;


}


}


interpolated_val = ((float)(line_buf_up[ptr_up] + line_buf_down[ptr_down])) / 2;


if(dominant)


img_out = medianfun(line_buf_up[2],line_buf_down[2],(int)interpolated_val);


else


img_out = (int)interpolated_val;


return img_out;





}

#endif

Tous ca c pour un pixel, j aimerai bien modifier la fontion ecrite en italique, gras pour la rendre en 4 pixels.
Merci de votre aide.
salut.

3 réponses

Messages postés
571
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
5 décembre 2013

Moi j'ai fait un truc comme ca

if ( (lpBits[tmp] == 0) && (lpBits[tmp+1] == 0 ) && (lpBits[tmp+2] == 0) )

remplacé en

long *p = (long *)&lpBits[tmp];

if ( (unsigned)*p == cTransparentColor )

avec cTransparentColor = RGB(0,0,0)
Messages postés
4
Date d'inscription
vendredi 28 janvier 2005
Statut
Membre
Dernière intervention
12 mars 2005

SnOOpss

Merci, pour ta reponse, est ce que tu as deja un programme qui fait ca??? moi je l ai essaye sur une image de mauvaise qualite. Et j ai reussi, l image etait modifiee et devenue bonne. Mais moi je veux utiliser ce programme que j ai avec un co-processuer, c pour cette raison je veux bien reduire le nombre de cycles lors de la compilation.
Je veux d abord au lieu de traiter l image pixel par pixel, je vais vais la traiter 4pixel par 4.
img_out[j][i] = calculate_out(&img_in[ptr_j][i],&img_in[ptr_j+1][i], &img_in[ptr_j+2][i],&img_in[ptr_j+3][i]); // c ca mon idee....
Alors si tu as une idee merci de me repondre.
Salut et a la prochaine.
Messages postés
571
Date d'inscription
samedi 3 avril 2004
Statut
Membre
Dernière intervention
5 décembre 2013

Désolé j avais mal compris en fait moi ce que je faisait cété de passer
les 3 valeur RGB codé sur 2 octet (max FF) (désolé je peux me planter
dans le nom ca date pour moi) en long codé sur 6 max FFFFFF mais je ne
sait pas si cete technique augmente la vitesse.

exmple



a = 50 ou 32 en hexa

b= 60 ou 3C en hexa

a/2 = 25 soit 19 en hexa

b/2 = 30 soit 1E en hexa



demande 2 division tandis que



a=323C soit 12860 en decimal

a/2=6430 en decimal soit 191E en hexa

ne demande q'une seule division pour arriver au meme resultat



On arrive aux meme resulat en ne faisant qu'une seule division pour toi
je sais pas mais j utlisais cette technique quand je bidouillé en
assembleur vu que la division etait une des fonctions ki demandait le
plus de temps cependant le fait d augementer le nombre de bit ralonge (
je pense) le temps de calcul donc fait des tests mais ce qui est sur
c'est que de bien choisir son type de variable ( int ou byte ou long )
a beaucoup d incidence sur un prog en assembleur



D ailleur pourquoi tu ne le programmes pas en assembleur j'ai vu que 'était possible de mettre des bout d asm dans du c++.



Autre chose y a plus rapide que la division par 2 quand tu interpoles

78 = 1001110 en binaire

78/2=39 = 100111

39/2=19=10011

en fait pour diviser par 2 tu retire le dernier bit



M'enfin je te dit de suite ca m'etonnerait que tu voyes de grosses
differences en c++, tu as un petit algorythme fait le en asm meme si tu
y connais rien je vois que ca pour optimiser ton code.