Venga posteo mi codigo.
Y lo explico detalladamente.
Lo simple es complejo amigo mio. Mejor programa en SDL que es mas sencillo.
:D :D :D Con esto tienes que saber de formatos de colores, offsets, bla, bla, bla...
/* Declaramos ciertas estructuras necesarias */
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
/* Cargamos el archivo en memoria */
_fp = fopen(path, "rb");
/* Comprobamos que se ha cargado */
if (_fp == NULL) {
_log->logln(" <error> loadpng - " CIMAGE);
_log->logln(" No se pudo cargar %s", path);
return false;
}
/* Iniciamos las estructuras */
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, (png_error_ptr)NULL);
if (png_ptr == NULL) {
_log->logln(" <error> loadpng " CIMAGE);
fclose(_fp);
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL) {
_log->logln(" <error> loadpng - " CIMAGE);
png_destroy_read_struct(&png_ptr, NULL, NULL);
fclose(_fp);
return false;
}
/* Leemos el archivo */
#if !defined(PNG_NO_STDIO)
png_init_io(png_ptr, _fp);
#else
png_set_read_fn(png_ptr, (png_voidp)_fp, png_read_data);
#endif
/* Obtenenmos cierta informacion */
png_read_info(png_ptr, info_ptr);
/* get width, height, bit-depth and color-type */
png_uint_32 width = 0; png_uint_32 height = 0; double gamma = 0;
png_get_IHDR(png_ptr,info_ptr,&width,&height,&_bit_depth,&_color_type,NULL,NULL,NULL);
/* Obtenemos el brillo */
png_get_gAMA(png_ptr, info_ptr, &gamma);
/* Pasamos a RGB */
if ((_bit_depth < 8) || (_color_type == PNG_COLOR_TYPE_PALETTE))
{
png_set_expand(png_ptr);
}
/* Eliminamos la información extra de los 16 bits */
if (_bit_depth == 16)
{
png_set_strip_16(png_ptr);
}
/* Si el color es algun tipo de codificacion gris lo pasamos a RGB */
if ((_color_type == PNG_COLOR_TYPE_GRAY) || (_color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
{
png_set_gray_to_rgb(png_ptr);
}
/* Eliminamos la información alpha */
if ((_color_type == PNG_COLOR_TYPE_RGBA) || (_color_type == PNG_COLOR_TYPE_GRAY_ALPHA))
{
png_set_strip_alpha(png_ptr);
}
/* Actualizamos la informacion */
png_read_update_info(png_ptr, info_ptr);
/* Volvemos a obtener la informacion */
png_get_IHDR(png_ptr,info_ptr,&width,&height,&_bit_depth,&_color_type,NULL,NULL,NULL);
/* Obtenemos el brillo */
png_get_gAMA(png_ptr, info_ptr, &gamma);
/* Establecemos el tamaño del contenedor */
setWidth(width); setHeight(height);
/* The easiest way to read the image: */
png_bytep row_pointers[height];
_log->logln("%i",png_get_rowbytes(png_ptr, info_ptr));
/* Reservamos memoria */
for (int row = 0; row < height; row++)
{
row_pointers[row] = (png_byte*)png_malloc(png_ptr, png_get_rowbytes(png_ptr, info_ptr));
}
/* Leemos toda la imagen */
png_read_image(png_ptr, row_pointers);
/* read rest of file, and get additional chunks in info_ptr - REQUIRED */
/* At this point you have read the entire image */
png_read_end(png_ptr, info_ptr);
/* clean up after the read, and free any memory allocated - REQUIRED */
png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
/* Vamos a cargar los datos */
for (int y=0;y<getHeight();y++)
{
for (int x=0;x<getWidth();x++)
{
/* Calculamos el desplazamiento */
unsigned long offset = (y*getWidth()+x);
/* Sacamos RGB del formato 24 bits */
unsigned char R = *(row_pointers[y]+(x*3));
unsigned char G = *(row_pointers[y]+(x*3)+1);
unsigned char B = *(row_pointers[y]+(x*3)+2);
unsigned short color = gp2x_video_RGB_color16(R,G,B);
_data16[offset] = color;
}
/* Liberamos memoria */
free(row_pointers[y]);
}
/* Cerramos el archivo */
fclose(_fp);
return true;
Este es parte del codigo de una libreria para programar interfaces graficos para la GP2X.
La funcion en cuestion carga un png de 8, 16, 24 bits (Solo he probado con 8 bits).
Si esta a 16 bits o menor de 8 la fuerfa a 8 bits.
Si tiene canal alpha lo quita.
Si esta en formato de paleta, que va a ser que si lo pasa a RGB, pero no RGB de 16 bits si no RGB de 24 bits, es decir un byte para el rojo otro byte para el verde y otro para el azul.
Es decir 3 bytes por pixel, como los colores de la paleta de 8 bits.
rrrrrrrrggggggggbbbbbbbb
Lo que hago es leer los datos de las filas y luego extraigo de ellas los datos para pasarlo
despues a formato 16 bits 565 con la funcion de rlyeh.
rrrrrggggggbbbbb
Puedes tomar data16 como gp2x_video_RGB[0].screen16*
que es el buffer de 16 bits de la minimal 0.B
En realidad en mi libreria data16 es un buffer intermedio.
A si que lo de setWidth() y setHeight() ahorratelo.
Para hacer esto tienes que tener: -static -lpng -lz -lpthread.
Ademas de añadir: #include <png.h>