By multiplying the height and width by the same value.

Still a little unclear on this...
I want the picture to fill either the width or height of the screen. How do I find what number to multiply them by. I am also using many different sizes of images.

erm, pretend you wish to scale it by a factor of 5, for the dest_width and dest_height, multiply the original bitmap width and height by 5

Sorry i posted while you posted, see edit above.

So I would do float aspect_ratio = bitmap->w/bitmap->h
or something?

Sorry about all the repeat questions, I keep writing a post while others are being put on.

Thanks for the help!8-)

Em, that code won't work, FMC. This is probably closer to what he wants (you don't want to just multiply by the screen width/height, you would get a HUGE image).

float factor = (SCREEN_W > SCREEN_H ? SCREEN_W : SCREEN_H) / float(SCREEN_W > SCREEN_H ? source->w : source->h);

stretch_blit(source, dest, 0, 0, source->w, source->h, destx, desty, source->w * factor, source->h * factor);

[edit] Did you change your code? I didn't see the division in your sw/sh before. Anyway, your code still won't work, because it will come out as an integer, not a float.

I just posted the code that does that.

BAF's code restated :

float factor;
if (SCREEN_W > SCREEN_H) {
  factor = SCREEN_W / float(source->w);
} else {
  factor = SCREEN_H / float(source->h);
}

This is not the same as :

BAF -
Your code doesn't decide which factor to use based on which y_to_y or x_to_x factor is smaller. It decides based on whether SCREEN_W is larger than SCREEN_H. So when SCREEN_W is larger than SCREEN_H then it will fail if (SCREEN_W / source->w) is greater than (SCREEN_H / source->h) since using the larger scale of the two results in excess magnification.

Quick example using your code
A screen of 200 X 100 and a bitmap of 10 X 50.
SCREEN_W is larger than SCREEN_H so :
factor = SCREEN_W / bitmap_width = 200 / 10
factor = 20
Magnifying the bitmap by 20 gives
20*10 = 200
20*50 = 1000
So it would fit x-wise , but would be way too tall.

It's nice when things can be coded nice and simply , but it just didn't work this time.:-/

FMC -

int a = 3;
int b = 4;
cout << (a / b) << endl;// will print 0 - integer division truncates any decimal portion
int x = 5;
float y = 4.5;
cout << (x*y) << endl;// will it print 20 or 22.5?

Does y get converted to int type or does x get converted to float type to perform the multiplication?

If the result ends up as float type , you passed a bad parameter unless the compiler supplies a conversion for you , which it shouldn't do in a function call.

If it ends up as int type then the compiler (un)helpfully converted y from 4.5 to 4 for you which gives you 20 instead of 22.5 for the scaled up size.

You need to cast the source->w and source->h to a float first , multiply by the appropriate scale and then cast it back to an integer.

This may still give you an off by one error due to truncation in the cast back to an integer. This wouldn't be very noticeable in the smaller dimension of the magnified picture but it might be noticeable in the larger dimension (the one that gets magnified to SCREEN_W or SCREEN_H). Imagine the screen was a sub-bitmap of the screen and had been outlined nicely but then there was a black line just above the bottom border. No fun.
Floats often come out as slightly less than the real value they would represent anyway. (.999999995 != 1) but it would still be truncated to 0.

Your way is actually a lot simpler than mine , I must not have read your post closely enough. Sorry.:-/

I wish you were coding a webpage, so i could just say:

convert 900x800 input.png output.png

But alas, it sounds like you aren't, so heres some code that should do what convert would have done in that scenario, plus some added centering.

The code hasn't been compiled or tested so YMMV, but you hopefully get the idea.