Question

Does anybody know if there is a min. size limit for BMP files in SDL framework to show them?
I’m asking you this because I tried but can not show correctly BMP files that are less than 20×20 pixels.(I’m using SDL for C++).

Code:

    bool successCondition = false;  
    if (SDL_Init(SDL_INIT_VIDEO) != 0) {
        printf("Unable to initialize SDL: %s\n", SDL_GetError());
        return 1;
    }
    atexit(SDL_Quit);

    SDL_Surface *screen;

    screen = SDL_SetVideoMode(640, 480, 24, SDL_DOUBLEBUF);
    if (screen == NULL) {
        printf("Unable to set video mode: %s\n", SDL_GetError());
        return 1;
    }

    // nueva imagen
    Image* imgSmile = new Image("Images/smile.bmp");

    SDL_Rect src, dest;
    src.x = 0;
    src.y = 0;
    src.w = imgSmile->getWidth();
    src.h = imgSmile->getHeight();
    dest.x = 50;
    dest.y = 20;
    dest.w = imgSmile->getWidth();
    dest.h = imgSmile->getHeight();
    SDL_BlitSurface(imgSmile->getSDLSurface(), &src, screen, &dest);
    SDL_Flip(screen);

    // nueva imagen
    Image* imgSmileRe = new Image("Images/smile.bmp");


    // Achico la imagen
    imgSmileRe->resize(10, 10);

    // Pego la imagen en la pantalla
    src.x = 0;
    src.y = 0;
    src.w = imgSmileRe->getWidth();
    src.h = imgSmileRe->getHeight();
    dest.x = 100;
    dest.y = 20;
    dest.w = imgSmileRe->getWidth();
    dest.h = imgSmileRe->getHeight();
    SDL_BlitSurface(imgSmileRe->getSDLSurface(), &src, screen, &dest);
    SDL_Flip(screen);


    //esperar para cerrar
    SDL_Event e;
    bool running = true;

    while(running) 
    {
        while(SDL_PollEvent(&e)) 
        {
            switch(e.type)
            {
                case SDL_QUIT:
                    running = false;
                    SDL_Quit();
                    break;
            }
        }
    }

    // libero memoria
    free(imgSmile);
    free(imgSmileRe);

    successCondition = true;

    return successCondition;

}  

And the code for resize:

void Image::resize(int newWidth, int newHeight)
{
    int widthSrc    = this->getWidth();
    int heightSrc   = this->getHeight();

    // Empty new image
    Image* temp = new Image(newWidth, newHeight);

    int posXDst = 0;
    int posYDst = 0;

    for(int posYSrc = 0; posYSrc < heightSrc ; posYSrc++){


        for(int posXSrc = 0; posXSrc < widthSrc; posXSrc++){

            posXDst = (posXSrc * newWidth) / widthSrc;
            posYDst = (posYSrc * newHeight) / heightSrc;

            Uint32 pixelImg = this->getPixel(posXSrc, posYSrc);


            if( posXSrc > 0 && posYSrc > 0 && newWidth > widthSrc && newHeight > heightSrc ){

                int fromY = (((posYSrc-1) * newHeight) / heightSrc);
                int fromX = (((posXSrc-1) * newWidth) / widthSrc);

                // interpolacion interna
                for (int y = fromY; y <= posYDst; y++){
                    for (int x = fromX; x <= posXDst; x++){

                        // pixel y posicion superior izquierdo
                        Uint32 pixelSI = this->getPixel(posXSrc-1, posYSrc-1);
                        int xSI = ((posXSrc-1) * newWidth) / widthSrc;
                        int ySI = ((posYSrc-1) * newHeight) / heightSrc;
                        // pixel y posicion superior derecho
                        Uint32 pixelSD = this->getPixel(posXSrc, posYSrc-1);
                        int xSD = (posXSrc * newWidth) / widthSrc;
                        int ySD = ((posYSrc-1) * newHeight) / heightSrc;
                        // pixel y posicion inferior izquierdo
                        Uint32 pixelII = this->getPixel(posXSrc-1, posYSrc);
                        int xII = ((posXSrc-1) * newWidth) / widthSrc;
                        int yII = (posYSrc * newHeight) / heightSrc;

                        // obtengo el pixel interpolado
                        Uint32 interpolatedPixel = this->getInterpolatedPixel( pixelSI, xSI, ySI, 
                                                                            pixelSD, xSD, ySD, 
                                                                            pixelII, xII, yII, 
                                                                            pixelImg, posXDst, posYDst, 
                                                                            x, y, temp->getFormat());

                        // coloco el pixel en la imagen destino
                        temp->putPixel( interpolatedPixel, x, y );
                    }
                }
            }

            // Pongo el pixel en las nuevas coordenadas
            temp->putPixel( pixelImg, posXDst, posYDst);
        }
    }

    this->copy(*temp);
    free(temp);
} 

Sorry for the spanish comments.
I’m using windows xp/ 7 the image is a smiley face in 24bits BMP file aprox 20×20 pixels.

Answer 1

Theoreticaly, there is no limit for the BMP size (as far as SDL is concerned).