Vertically invert a surface in SDL - Revision history

64.134.50.170 at 11:36, 1 June 2005

2005-06-01T11:36:37Z

64.134.50.170 at 10:56, 1 June 2005

2005-06-01T10:56:38Z

64.134.50.170 at 01:53, 31 May 2005

2005-05-31T01:53:36Z

64.134.50.170 at 01:52, 31 May 2005

2005-05-31T01:52:42Z

64.134.50.170 at 01:20, 31 May 2005

2005-05-31T01:20:05Z

New page

This code flips an <code>SDL_Surface</code> upside-down by using a buffer the size of one line of the image to swap the first and last successively until the middle is reached.

<nowiki>
int invert_surface_vertical(SDL_Surface *surface)
{
/* buffer big enough for one line of this image */
Uint8 *line;
Uint8 *a, *b;
Uint16 pitch;

pitch = surface->pitch * sizeof(Uint8);

line = (Uint8*)malloc(pitch);

if( line == NULL )
return -1;

/* let us begin swapping the first and last lines
of an ever-narrowing area of the image */
a = (Uint8*)surface->pixels;
b = a + pitch * (surface->h - 1);

while( a < b ) {
memcpy(line, b, pitch);
memcpy(b, a, pitch);
memcpy(a, line, pitch);

a += pitch;
b -= pitch;
}

free(line);

return 1;
}
</nowiki>

← Older revision		Revision as of 11:36, 1 June 2005
Line 1:		Line 1:
−	This code flips an <code>SDL_Surface</code> ~~upside-down~~ by ~~using a buffer~~ the ~~size of one line~~ of the image to ~~swap~~ the ~~first and~~ last ~~successively until~~ the ~~middle is reached~~.	+	This code vertically flips the content of an <code>SDL_Surface</code>. It operates by first copying out the first row of the image, then overwriting the first with the last, then the last with the second, the second with the next to last, the next to last with the third, and so on. After this shuffling has been completed, the top half of the image is already correct, and the bottom half begins one row too late. At this point, a single <code>memmove</code> corrects that shift, and the row copied out at the beginning of the process is put back.
−
−	~~<nowiki>~~
−	~~int invert_surface_vertical(SDL_Surface *surface)~~
−	{
−	~~/* buffer big enough for one line of~~ this ~~image */~~
−	~~Uint8 *line;~~
−	~~Uint8 a~~, b;
−	~~Uint16 pitch;~~
−
−	~~if( SDL_MUSTLOCK(surface) ) {~~
−	~~if( SDL_LockSurface(surface) < 0 ) {~~
−	~~return -2;~~
−	}
−	}
−
−	~~pitch = surface->pitch * sizeof(Uint8);~~
−
−	~~line = (Uint8*)malloc(pitch);~~
−
−	~~if( line == NULL )~~
−	~~return -1;~~
−
−	~~/* let us begin swapping~~ the ~~first and last lines~~
−	~~of an ever-narrowing area~~ of the image */
−	~~a = (Uint8*)surface->pixels;~~
−	~~b = a + pitch * (surface->h - 1);~~
−
−
−	~~while( a < b ) {~~
−	~~/* memcpy(dest~~, ~~src, len) */~~
−	~~memcpy(line, b, pitch);~~
−	~~memcpy(b, a, pitch);~~
−	~~memcpy(a, line, pitch);~~
−
−	~~a += pitch;~~
−	~~b -= pitch;~~
−	}
−
−	~~free(line);~~
−
−	~~if( SDL_MUSTLOCK(surface) ) {~~
−	~~SDL_UnlockSurface(surface);~~
−	}
−
−	~~return 0;~~
−	}
−	~~</nowiki>~~
−
−
−	~~Here's another~~ one ~~that does one fewer <code>memcpy</code> per two rows~~, ~~but then must do~~ a ~~large~~ <code>memmove</code> ~~near~~ the ~~end. This one I believe would be less computationally intensive. And,~~ of ~~course, I haven't tested this code in SDL yet~~.

	<nowiki>		<nowiki>

@@ Line 10: / Line 10: @@
      if( SDL_MUSTLOCK(surface) ) {
-         if( SDL_LockSurface(surface) ) {
+         if( SDL_LockSurface(surface) < 0 ) {
              return -2;
+         }

@@ Line 44: / Line 44: @@
+     }
-     return 1;
+     return 0;
+}
 </nowiki>

@@ Line 8: / Line 8: @@
      Uint8 *a, *b;
      Uint16 pitch;
      pitch = surface->pitch * sizeof(Uint8);
@@ Line 20: / Line 26: @@
      a = (Uint8*)surface->pixels;
      b = a + pitch * (surface->h - 1);
      while( a < b ) {
          memcpy(line, b, pitch);
          memcpy(b, a, pitch);
@@ Line 31: / Line 39: @@
      free(line);
      return 1;
+}
 </nowiki>