Problème avec le C et MSYS

[Lionel Debroux]

Sur Nspire, il n'y a pas (encore) de librairie graphique similaire à  ExtGraph ou Genlib, les deux principales librairies graphiques pour TI-68k, ou hpg/ggl (pour HP-49G+/50G+), qui faciliterait le portage de jeux / la création de nouveaux jeux.
Mais il me semble qu'il est possible de se synchroniser sur le rafraîchissement de l'écran sur Nspire également, vérifie la page MMIO de Hackspire :

[Chockosta]

Bon, j'ai essayé de me coder un petit système de buffer tout simple.
Mais sur l'émulateur, j'ai un très joli plantage...

Dans le main :

Code: Select all

buffer buf1;
bufClear (buf1);

la struct buffer :

Code: Select all

typedef struct
{
    int pixel[320][240];
} buffer;

et la fonction bufClear :

Code: Select all

void bufClear (buffer *buf) //clears the buffer
{
    memset (buf, 15, sizeof(buffer));
}

Quelqu'un voit-il l'origine du problème ?

[Lionel Debroux]

J'aurais plutà´t tendance à  utiliser "uint8_t pixel[320*240*BITS_PER_BYTE/BITS_PER_PIXEL]", c'est à  dire

Code: Select all

uint8_t pixel[320*240/2]

dans la config normale. Un tableau de dimension 1 est beaucoup plus facile à  utiliser qu'un tableau de dimension = 2 :

[Levak]

Je suis intéressé par la réponse à la question "pourquoi ?".
Limite, faire un tableau de tableau, mais un tableau à une dimension, je trouve ça une prise de tête, pleins de multiplication, d'additions etc ... je vois pas en quoi ça serait plus simple pour le processeur que deux dimensions.

[Chockosta]

Hum, à ce qu'il me semble, les tableaux 2d sont des tableaux 1d gérés différemment par le compilo (tapez moi pas si je dis une bêtise !).
Ta méthode permet certes d'utiliser moitié moins d'octets, mais c'est bien plus galère pour modifier les données.

Je vais me renseigner sur le coup du uint8_t.

Je pense pas que cela résolve mon bug, et vu la complexité de la mise en place (changer 2 ou 3 fonctions, attention !) je préfère pas le mettre en place tout de suite...

EDIT : Le uint8_t, c'est vrai que c'est mieux que le int pour ça...
EDIT 2 : C'est le coup du bufClear qui fait passer l'émulateur en mode debug (comment on en sort d'ailleurs ?)

[Levak]

Pas la bonne adresse ?

[Lionel Debroux]

Les tableaux 2D sont compilés de la façon suivante:
* un tableau de n pointeurs;
* n tableaux de m éléments.
Autrement dit, un adressage indirect et fragmenté, peu adapté aux opérations collectives sur l'ensemble du tableau, comme le sont justement les memcpy et memset que tu voudrais utiliser pour un système de buffer :
C'est pour ça qu'ExtGraph et Genlib, entre autres, n'utilisent pas de tableaux char [240/8][128], mais des tableaux char [240/8*128] :;):

mais c'est bien plus galère pour modifier les données.

Non, ce sont plutà´t les tableaux 2D qui sont galère, voir plus haut :
Question de goût, mais A(tab,x,y) (avec la macro A qui va bien) et tab[x][y], ou carrément A(x,y) si toutes les opérations sont faites avec "tab", ne sont pas très différents.

[Chockosta]

Ben, j'ai essayé avec :
la struct modifiée buffer (pas encore divisé le nombre d'octets par 2)

Code: Select all

typedef struct
{
    uint8_t pixel[320*240];
} buffer;

et le bufClear identique, lorsque je l'appelle, toujours un bug. J'ai du mal a comprendre.

[JayTe]

+1 par rapport à ce que dit Lionel Debroux, un tableau 1d est bien plus simple à utiliser.

Pour le problème de chockosta, je pense que le memset n'est pas fait à la bonne addresse.
En gardant la structure en 2d il faudrait faire:

Code: Select all

void bufClear (buffer *buf) //clears the buffer
{
    int i;
    for(i = 1; i  320; i++)
    memset (buf-pixel[i], 15, sizeof(buf-pixel[i]));
}


ou alors en 1d, buf étant déclaré comme uint8_t buf[320*240/2];

Code: Select all

void bufClear(uint_t* buf)
{
    memset(buf, 15, 320*240/2);
}


[Levak]

Permet moi de dire que je suis pas vraiment d'accord.
tab[x][y] est une opération très rapide, d'abord un tab[x] qui renvoie un pointeur p à la position tab + x, puis un p[y] qui renvoie un pointeur q à la position p + y, autrement dit deux additions.

En 1 dimension, faire la même chose revient à faire une multiplication puis une addition, étant donné que j'ai le choix, je ferais 2 additions plutôt qu'une multiplication et une addition.

Cependant, pour des accès de type linéaires (genre, efface le buffer) où de toute manière il faut parcourir tous les éléments, oui, dans ce cas, une seule addition suffit, mais dans ce cas précis.