Hola, estoy haciendo un programa que crea archivos bmp de las dimensiones que yo quiera, y lo rellene en gris, y listo. El programa para las dimensiones 100x100 funciona, pero más allá falla algunas veces, principalmente si es más de 1000;
¿Pueden decirme como eliminar ese error que dice SIGSEV en chkstk_ms()??
¿Es mi codigo o sólo el compilador?
Si uso valores en WIDTH Y HEIGHT de 100, todo normal. Si me paso a 10000, se tranca y devuelve en depuracion SIGSEV en un chkstk_ms(), y ni muestra el primer printf. ¿Debo reinstalar el compilador o algo así? Al menos el error debería ser puntual, y no general.
Gracias de antemano.
#include <iostream>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
#define WIDTH 10000
#define HEIGHT 10000
///DONE:
/// Mas o menos crea la imagen.
/// Cuando se pasa de 1000 ambos, ocurre una falla.
/// del tipo Violacion de Segmento.
///Error oculto solucionado: No consideraba las iniciales BM (2 bytes) al tamaño
///del archivo, muy importantes.
///TO-DO:
/// -Fill the image with interesting data.
/// -El programa lo unico que debe hacer es soportar colorear de azul,
/// un cuadro de 1000, pixeles.
/// -Hay un problema con lo que significa el manejo del formato, en si mismo
/// -No puedo exceder los 1000px, debe ser algo relacionado con el padding.
/// -Si grabó tal cual se le asignaron los valores a la matriz,
/// por tanto el error es de interpretacion. La escritura está bien.
/// aprender como manejar los bytes y dibujar un cuadrado, o algo así.
/// -Si soportó el array de bmp_pixeles, pero grabó basura
/// -Sin embargo, el formato quedó intacto.
using namespace std;
char bmp_sign[2] = {'B', 'M'}; /// = "BM";
struct bmp_format{
unsigned int filesize; /// = filesize
unsigned short reserved_a; /// = 0;
unsigned short reserved_b; /// = 0;
unsigned int start_of_data_image; /// = 54
unsigned int bitmap_header_size;
unsigned int width;
unsigned int height;
unsigned short number_of_planes;
unsigned short bits_per_pixel;// = 1;
unsigned int compression; /// = 0;
unsigned int size_of_image; /// = 0;
unsigned int horizontal_resolution; /// = 0
unsigned int vertical_resolution; /// = 0;
unsigned int size_of_color_palette;
unsigned int counter_of_interesting_colors;
};
struct bmp_pixel{
unsigned char red;
unsigned char green;
unsigned char blue;
};
int main()
{
FILE *bmp_file;
FILE *debug_image;
FILE *debug_binary;
printf("Abriendo archivos bmp y debug respectivos\n");
bmp_file = fopen("C:\\output.bmp", "w+b");
//debug_image = fopen("C:\\image_in_bin.hex", "w+b");
//debug_binary = fopen("C:\\memory_in_bin.hex", "w+b");
bmp_format bmp_format;
memset(&bmp_format, 0, sizeof(bmp_format));
printf("Estableciendo bmp format a NULL para mantenerlo limpio\n");
unsigned int number_of_data_bytes;
///Initializing data
///TO-DO: Design a better method to adjust values than
///hard-code it.
bmp_format.start_of_data_image = 54;
bmp_format.bitmap_header_size = 40;
bmp_format.width = WIDTH;
bmp_format.height = HEIGHT;
bmp_format.number_of_planes = 1;
bmp_format.bits_per_pixel = 24;
bmp_format.compression = 0;
bmp_format.size_of_image = number_of_data_bytes;
bmp_format.horizontal_resolution = 0;
bmp_format.vertical_resolution = 0;
bmp_format.size_of_color_palette = 0;
bmp_format.counter_of_interesting_colors = 0;
///TODO: This value must have a formule:
/// -bmp_header + ([width * height] * 3 bytes of rgb)
///TODO: Use it over hardcoded values.
number_of_data_bytes = (WIDTH * HEIGHT) * 3;
bmp_format.filesize = 2 + sizeof(bmp_format) + number_of_data_bytes;
printf("Ya fueron rellenados todos los campos de bmp format!!\n");
fwrite((char *) &bmp_sign, 2, 1, bmp_file);
fwrite((char *) &bmp_format, sizeof(bmp_format), 1, bmp_file);
printf("Grabando bmp format + la señal de BM\n");
/*struct bmp_pixel pixeles[WIDTH][HEIGHT];
*/
char pixeles[WIDTH * HEIGHT * 3];
for(int i = 0; i < number_of_data_bytes; i++){
pixeles[i] = 0x50;
}
/*
///Clear pixeles and zero it to avoid filter my
///system data on memory swap.
memset(pixeles, 0, sizeof(pixeles));
for(int e = 0; e < WIDTH; e = e + 5){
for(int i = 0; i < HEIGHT; i++){
pixeles[i][e].blue = 0xDE;
pixeles[i][e].red = 0xAD;
pixeles[i][e].green = 0xff;
}
}*/
///fwrite((char *) pixeles, number_of_data_bytes, 1, debug_image);
///fwrite((char *) pixeles, number_of_data_bytes, 1, debug_binary);
///fwrite((char *) pixeles, (WIDTH * HEIGHT * 3), 1, bmp_file);
fclose(bmp_file);
cout << "Dibujador de BMP. En progreso y con futuro." << endl;
return 0;
}
La pila es finita, usa memoria dinamica (o una variable global, que ira a la sección de datos)/
Ah, no entiendo bien eso. Gracias por responderme. Que me aconsejas exactamente?? Colocó el bmp header como un puntero??? y de allí lo grabó?? Es eso lo que me dices??
Disculpa por las molestias, no tengo mucho conocimiento sobre la pila y los punteros, el problema entonces no está en mi lógica de código?? Pregunto por si acaso.
EDIT: 1
Ya hice algo, cambie el array a dinamico y me compilo sin problemas. Eso es lo que entendí. Gracias
Una ultima ayuda. ¿Como traduzco esto
struct bmp_pixel pixeles[WIDTH][HEIGHT];
a un array dinámico pero de estructura?? Por favor, ayuda que es lo único que me faltta para empezar a dibujar sobre el Bitmap con total seguridad.
Gracias de antemano
yo lo haría así:
array = malloc(sizeof(bmp_pixel)*WIDTH*HEIGHT);
pero así tendrías que accederlo de esta forma:
pixelXY = array[X*WIDTH+Y];
para accederlo de forma bidimensional, busca bidimensional dynamic array c en google
No entiendo porque mezclas C++ con C se me hace innecesario usar printf y cout en un programa además , si lo que estás usando es C++, deberías usar cstdio,cstdlib.... etc como debe ser pero en fin ... yendo a lo que es tú duda debes usar una pila dinamica o quizá una lista para que tú programa mejore. ;)
Un detalle para cuando leas o escribas BMP, a parte de lo que te comenten por aquí.
Cuando comienzas a escribir los bytes, cada fila ha de ocupar un número de bytes divisible entre 4. Es decir, si hay 2 columnas, serían 6 bytes. Para ocupar los bytes que faltan, se añaden dos bytes de relleno o padding.
Para una idea menos abstracta, aquí tienes un ejemplo: https://en.wikipedia.org/wiki/BMP_file_format#Example_1 (https://en.wikipedia.org/wiki/BMP_file_format#Example_1)