SoloCodigo

hla!

Tengo un par de dudas. Se trata sobre el modo grafico 13h (320x200x256). Para utilizar tal modo en el sistema MSDOS se debia tratar de la siguiente manera:

Se tenia que declarar un puntero al principio de la memoria de video, la cual era un vector de 64k (320 bytes x 200 bytes) y asi podias escribir graficamente modificando el valor del byte al cual querias acceder.

Pues bien, sobre esto tengo un par de dudas. La primera es que si en sistemas UNIX (linux en particular) existe tal modo grafico? y si es asi, este es tratado de la misma forma que en DOS?

La segunda pregunta va un poco mas alla. Esto es, todos los modos graficos funcionan de igual manera? En modo 13h la longitud del array viene determinada porque tiene 256 colores, es decir, 2^8, siendo 1 byte la info de color de cada pixel, y tiene 320 pixel de ancho y 200 pixels de alto, asi pues el tamaño del array es 320 pixels multiplicado por 200 pixels y multiplicado por 1 byte.

Asi, pienso que un modo grafico de resolucion 640 x 480 con 256 colores sera un array de 307,2 k de longitud. Esto es asi o funciona de otra manera?

Me he explicado como el culo, pero si alguien sabe de esto le agradeceria que me lo explicara. Gracias.

Saludos

dheak ahi va un ejemplo:

#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <asm/page.h>

   
int PutPixel (unsigned char R, unsigned char G, unsigned char B, int x, int y);

struct fb_var_screeninfo vinfo;      //informacion sobre la pantalla
   struct fb_fix_screeninfo finfo;
   unsigned char *screen=NULL;


int main(int argc, char *argv[])
{
   int fbfd;
   
      
   long int screensize;         //variables para hacer el mapeado en memoria del "fichero"
   
   /* Abrimos el dispositivo frame buffer en modo lectura/escritura */
   if (!(fbfd=open("/dev/fb0", O_RDWR)))
   {
           printf("Error al abrir el framebuffer.n");
           return -1;
    }
   
    /* Obtenemos información fija de la pantalla */
    if (ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo))
   {
            printf("Error al leer información fija.n");
           return -2);
    }

   /* Leemos información variable de la pantalla */
    if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo))
   {
            printf("Error al leer informacion variablen");
            return -3;
   }
   
   
   // Mapeo el framebuffer en memoria.
   // Lo que hace la funcion map es mapear todo el archivo en memoria con lo que
   // es mas facil trabajar con el. A partir de aqui imagina que screen apunta a
   // A000:0000 y solo tienes que tener en cuenta que ahora son 3 bytes para cada pixel(24 bits de color, en el orden Azul verde rojo)
   // o 4 bytes (32 bits de color, Azul Verde Rojo Transparencia). Es decir, escribes directamente
   // la combinacion que forma el color, no das un indice dentro de la paleta como con el modo 13h.
   screensize= ((unsigned long)finfo.smem_len) + ((unsigned long)(finfo.smem_start) & (~PAGE_MASK));
   screen=mmap(NULL, screensize, PROT_WRITE, MAP_SHARED, fbfd, 0);
   
   if(screen == NULL)
   {
      printf("Error al mapear el archivo en memorian.");
      return -4;
   }

   // en vinfo y finfo tienes informacion sobre la pantalla
   //ancho = vinfo.xres;
   //alto = vinfo.yres;
   //bits de color = vinfo.bits_per_pixel;
   
   //pinto un pixel de color blanco en (100,100)
   PutPixel(255,255,255, 100, 100);

   // Libero los recursos
   munmap(screen, screensize);
    close(fbfd);
   

      return 0;
}
       



int PutPixel (unsigned char R, unsigned char G, unsigned char B, int x, int y)
{
   unsigned char *fb;
   
   int offy, offx;

   
   //offset debido al valor de x. Depende de los bytes que ocupe cada pixel.
   offx=x*vinfo->bpp/8;
   
   //offset debido al valor de y. Entre linea y linea no siempre hay una diferencia
   //igual a la resolucion horizontal(al menos en mi ordena no:P) asi que mejor utiliza
   //el campo Lenline para ello.
   offy=y*finfo->lenLine;
   
   //me situo en la posicion indicada
   fb=screen+offy+offx;
   
   //escribo el color... al reves.
   fb[0]=B;
   fb[1]=G;
   fb[2]=R;
   
   return 0;
}