Problème avec le C et MSYS

[Chockosta]

J'ai fait exactement ça, aucun changement...
(enfin sauf le /2)

C'est la meme histoire avec

Code: Select all

for (i=0; i320*240; i++)
{
    buf-pixel[i] = 0xFF;
}

[Lionel Debroux]

Levak, tu noteras que je ne me suis pas placé, au premier abord, sur le terrain de l'efficacité (qui dépend de la plate-forme), mais sur celui de la facilité d'utilisation, et de l'adaptation aux opérations collectives (qui fait partie de l'efficacité aussi bien que de la facilité d'utilisation) :

Je suis d'accord que tab[x][y] peut être plus rapide que tab[x*n+y] selon la plate-forme (sur Nspire, ça doit être le cas), mais comme je l'ai écrit et que JayTe l'a illustré, ce que tu peux gagner en accès unique est perdu en accès collectif, par la nécessité d'utiliser beaucoup d'appels courts à  memcpy/memset (sans parler du fait que les accès mémoire sont légèrement moins linéaires, il faut garder une ligne de cache pour le tableau de pointeurs, qui consomme également marginalement plus de mémoire) :
Les librairies graphiques que je connais utilisent des tableaux 1D, et il y a une bonne raison à  celà  :


Chockosta: tu es en train d'essayer d'écrire 320*240 octets vers un tableau qui, avec la config par défaut du contrà´leur d'écran, n'en contient que 320*240/2 :;):

[Chockosta]

Là je touche pas à l'écran standard, je joue juste avec une structure contenant un tableau.

[Chockosta]

J'ai trouvé... La calculette est pas d'accord pour m'accorder autant de place.
Ca marche avec le nombre d'octets divisé par 100.
Avec le nombre d'octets divisé par 2, ça marche, mais ça reboot à la fin du programme (si je fais un memset de 0xFF) ou ca freeze l'émulateur (avec un memset de 0x00).
Je peux donc faire une croix dessus.

[Lionel Debroux]

Je n'avais pas pensé à  ça...
As-tu alloué cette structure sur la pile, ou avec malloc ? Il faudrait l'allouer avec malloc, qui permet habituellement d'allouer des blocs jusqu'à  au moins 8 MB.

[Chockosta]

En effet, j'ai alloué dans la pile.
Je vais essayer dans le tas. Après tout, me faut seulement 38 Ko.

EDIT : Ca ne crashe pas !
Par contre, je suis pas bien doué (pauvre seconde que je suis) pour trouver l'algorithme gérant deux pixels par octet.
Est-ce bien :

Code: Select all

void bufSetData (buffer *buf, uint8_t data, int x, int y) //put a number in the buffer. buf is the buffer, data the number, x  y the coords.
{
    if (x/2 == 1)
        buf[y*160+x/2] = buf[y*160+x/2]/16 + data;
    else
        buf[y*160+x/2] = buf[y*160+x/2]%16 + data*16;
}

Ou pas du tout ?

[JayTe]

C'est pas mal, mais c'est pas encore tout à fait ça

Déjà dans la première condition, il faudrait remplacer x/2 par x%2 (vu que tu veux savoit si x est pair ou impair).

Ensuite dans le cas ou x % 2 == 1, le but est de conserver les 4 bits de poids fort de buf[y*160+x/2]. Si tu divises par 16, tu conserves bien ces 4 bits mais tu les décale aussi vers la droite, donc ils seront écrasés quand tu ajouteras data. Il faut donc soit remultiplier par 16 ensuite, soit faire un décalage de 4 bits vers la gauche (
A part ça la partie après les else m'a l'air correcte

JayTe

[Chockosta]

Merci ! Ca marche parfaitement !
J'ai une bibliothèque de gestion de buffers opérationnelle !

buffer.h

Code: Select all

/// ////////////////////// ///
///        BUFFER.H        ///
/// a simple buffer system ///
///      by Chockosta      ///
/// ////////////////////// ///

#ifndef _BUFFER_H_
#define _BUFFER_H_

typedef uint8_t buffer;

buffer* bufCreate (); //allocate a buffer
void bufDelete (buffer *buf); //free a buffer
void bufSetData (buffer *buf, uint8_t data, int x, int y); //put a number in the buffer (may not be used by a human being)
uint8_t bufGetData (buffer *buf, int x, int y); //returns a number which is in the buffer (may not be used by a human being)
void bufSetPixel (buffer *buf, int x, int y, int color); //set a pixel
int bufGetPixel (buffer *buf, int x, int y); //returns a pixel's color
void bufDisplay (buffer *buf); //displays the buffer
void bufClear (buffer *buf); //clears the buffer
void bufCopy (buffer *buf, buffer *buf2); //copy the buffer to another buffer
inline void screenSetPixel (int x, int y, int color); //set a pixel.

#endif


buffer.c

Code: Select all

#include os.h
#include "buffer.h"

buffer* bufCreate () //allocate a buffer
{
    uint8_t *ptr = malloc (38400 * sizeof(uint8_t));
    return ptr;
}

void bufDelete (buffer *buf) //free a buffer
{
    free (buf);
}

void bufSetData (buffer *buf, uint8_t data, int x, int y) //put a number in the buffer
{
    if (x%2 == 1)
        buf[y*160+x/2] = buf[y*160+x/2]/16*16 + data;
    else
        buf[y*160+x/2] = buf[y*160+x/2]%16 + data*16;
}

uint8_t bufGetData (buffer *buf, int x, int y)
{
    if (x%2 == 1)
        return buf[y*160+x/2]%16;
    else
        return buf[y*160+x/2]/16;
}

void bufSetPixel (buffer *buf, int x, int y, int color) //set a pixel
{
    if (x=0  x320  y=0  y240  color=0  color16)
        bufSetData (buf, color, x, y);
}

int bufGetPixel (buffer *buf, int x, int y) //returns a pixel's color
{
    if (x=0  x320  y=0  y240)
        return bufGetData (buf, x, y);
    else
        return 0;
}

void bufDisplay (buffer *buf) //displays the buffer
{
    int i, j;
    for (i=0; i320; i++)
    {
        for (j=0; j240; j++)
        {
            screenSetPixel (i, j, bufGetData(buf, i,j));
        }
    }
}

void bufClear (buffer *buf) //clears the buffer
{
    memset (buf, 0xFF, 38400 * sizeof(uint8_t));
}

void bufCopy (buffer *buf, buffer *buf2) //copy the buffer to another buffer
{
    int i;
    for (i=0; i38400; i++)
    {
        buf2[i] = buf[i];
    }
}

inline void screenSetPixel(int x, int y, int color)
{
  unsigned char* p = (unsigned char*)(SCREEN_BASE_ADDRESS + ((x  1) + (y  7) + (y  5)));
  *p = (x  1) ? ((*p  0xF0) | color) : ((*p  0x0F) | (color  4));
}