diff --git a/ss2011/hcs/1c_henrich.txt b/ss2011/hcs/1c_henrich.txt new file mode 100644 index 00000000..ea9b51e0 Binary files /dev/null and b/ss2011/hcs/1c_henrich.txt differ diff --git a/ss2011/hcs/hcs.txt b/ss2011/hcs/hcs.txt new file mode 100644 index 00000000..0ffb6568 --- /dev/null +++ b/ss2011/hcs/hcs.txt @@ -0,0 +1,30 @@ +78 54 96 0 +01001110 00110110 01100|000 00000000 +01001110 00110110 01100|111 11111111 +78 54 103 255 + +78 54 120 0 +01001110 00110110 01111|000 00000000 +01001110 00110110 01111|111 11111111 +78 54 127 255 + +01001110 00110110 011|00000 00000000 +01001110 00110110 011|11111 11111111 + + + + +31 19 0 0 -> No1 +00011111 00010011 0000000|00 00000000 +31 19 59 255 -> NO1 +00011111 00010011 0001110|11 11111111 + +31 19 60 0 -> No2 +00011111 00010011 0001111|00 00000000 +31 19 63 255 -> No2 +00011111 00010011 0001111|11 11111111 + +31 19 64 0 -> NO1 +00011111 00010011 0010000|00 00000000 +31 19 127 255 -> NO1 +00011111 00010011 0011111|11 11111111 \ No newline at end of file diff --git a/ss2011/hcs/hcs_1b.txt b/ss2011/hcs/hcs_1b.txt new file mode 100644 index 00000000..0f402339 --- /dev/null +++ b/ss2011/hcs/hcs_1b.txt @@ -0,0 +1,25 @@ +Ulf Gebhardt 1574373 + +Frage: Erklren Sie die Begriffe Chromaticity und Spektralfarblinie. + +Antwort: + +Chromaticity: + +Die Farbsttigung (Chromaticity), Sttigung ist neben Farbton und Helligkeit +eine der drei vom Menschen als grundlegend empfundenen Eigenschaften einer Farbe. +Sie beschreibt die Qualitt der Farbwirkung. Spezielle Wertigkeiten wie Buntheit, +Farbigkeit (Farbintensitt), Chromatizitt, Farbtiefe, Brillanz, Graustich beschreiben +verwandte Phnomene fr bunte und unbunte Farben. + + +Spektralfarblinie: + +Die Spektralfarblinie ist Begrenzung der Farbsttigung, wenn man sie zweidimensional +auftrgt. Formal: Die x,y Kordinaten der monochromatischen Farbreize erzeuegn die +Spektralfarblinie. Sie bildet die konvexe Hlle der Farbsttigungskoordinaten der +Farbreize + + + +Sry fr die Versptung ;-) \ No newline at end of file diff --git a/ws2010/gdi3/p5/SDL/test/testsprite.c b/ws2010/gdi3/p5/SDL/test/testsprite.c new file mode 100644 index 00000000..6d9e0a85 --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/testsprite.c @@ -0,0 +1,323 @@ +/* Simple program: Move N sprites around on the screen as fast as possible */ + +#include +#include +#include +#include +#include +#include + +#include "SDL.h" + +#define NUM_SPRITES 100 +#define MAX_SPEED 1 + +SDL_Surface *sprite; +int numsprites; +SDL_Rect *sprite_rects; +SDL_Rect *positions; +SDL_Rect *velocities; +int sprites_visible; +int debug_flip; +Uint16 sprite_w, sprite_h; + +/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ +static void quit(int rc) +{ + SDL_Quit(); + exit(rc); +} + +int LoadSprite(char *file) +{ + SDL_Surface *temp; + + /* Load the sprite image */ + sprite = SDL_LoadBMP(file); + if ( sprite == NULL ) { + fprintf(stderr, "Couldn't load %s: %s", file, SDL_GetError()); + return(-1); + } + + /* Set transparent pixel as the pixel at (0,0) */ + if ( sprite->format->palette ) { + SDL_SetColorKey(sprite, (SDL_SRCCOLORKEY|SDL_RLEACCEL), + *(Uint8 *)sprite->pixels); + } + + /* Convert sprite to video format */ + temp = SDL_DisplayFormat(sprite); + SDL_FreeSurface(sprite); + if ( temp == NULL ) { + fprintf(stderr, "Couldn't convert background: %s\n", + SDL_GetError()); + return(-1); + } + sprite = temp; + + /* We're ready to roll. :) */ + return(0); +} + +void MoveSprites(SDL_Surface *screen, Uint32 background) +{ + int i, nupdates; + SDL_Rect area, *position, *velocity; + + nupdates = 0; + /* Erase all the sprites if necessary */ + if ( sprites_visible ) { + SDL_FillRect(screen, NULL, background); + } + + /* Move the sprite, bounce at the wall, and draw */ + for ( i=0; ix += velocity->x; + if ( (position->x < 0) || (position->x >= (screen->w - sprite_w)) ) { + velocity->x = -velocity->x; + position->x += velocity->x; + } + position->y += velocity->y; + if ( (position->y < 0) || (position->y >= (screen->h - sprite_w)) ) { + velocity->y = -velocity->y; + position->y += velocity->y; + } + + /* Blit the sprite onto the screen */ + area = *position; + SDL_BlitSurface(sprite, NULL, screen, &area); + sprite_rects[nupdates++] = area; + } + + if (debug_flip) { + if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { + static int t = 0; + + Uint32 color = SDL_MapRGB (screen->format, 255, 0, 0); + SDL_Rect r; + r.x = (sin((float)t * 2 * 3.1459) + 1.0) / 2.0 * (screen->w-20); + r.y = 0; + r.w = 20; + r.h = screen->h; + + SDL_FillRect (screen, &r, color); + t+=2; + } + } + + /* Update the screen! */ + if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { + SDL_Flip(screen); + } else { + SDL_UpdateRects(screen, nupdates, sprite_rects); + } + sprites_visible = 1; +} + +/* This is a way of telling whether or not to use hardware surfaces */ +Uint32 FastestFlags(Uint32 flags, int width, int height, int bpp) +{ + const SDL_VideoInfo *info; + + /* Hardware acceleration is only used in fullscreen mode */ + flags |= SDL_FULLSCREEN; + + /* Check for various video capabilities */ + info = SDL_GetVideoInfo(); + if ( info->blit_hw_CC && info->blit_fill ) { + /* We use accelerated colorkeying and color filling */ + flags |= SDL_HWSURFACE; + } + /* If we have enough video memory, and will use accelerated + blits directly to it, then use page flipping. + */ + if ( (flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { + /* Direct hardware blitting without double-buffering + causes really bad flickering. + */ + if ( info->video_mem*1024 > (height*width*bpp/8) ) { + flags |= SDL_DOUBLEBUF; + } else { + flags &= ~SDL_HWSURFACE; + } + } + + /* Return the flags */ + return(flags); +} + +int main(int argc, char *argv[]) +{ + SDL_Surface *screen; + Uint8 *mem; + int width, height; + Uint8 video_bpp; + Uint32 videoflags; + Uint32 background; + int i, done; + SDL_Event event; + Uint32 then, now, frames; + + /* Initialize SDL */ + if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { + fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); + return(1); + } + + numsprites = NUM_SPRITES; + videoflags = SDL_SWSURFACE|SDL_ANYFORMAT; + width = 640; + height = 480; + video_bpp = 8; + debug_flip = 0; + while ( argc > 1 ) { + --argc; + if ( strcmp(argv[argc-1], "-width") == 0 ) { + width = atoi(argv[argc]); + --argc; + } else + if ( strcmp(argv[argc-1], "-height") == 0 ) { + height = atoi(argv[argc]); + --argc; + } else + if ( strcmp(argv[argc-1], "-bpp") == 0 ) { + video_bpp = atoi(argv[argc]); + videoflags &= ~SDL_ANYFORMAT; + --argc; + } else + if ( strcmp(argv[argc], "-fast") == 0 ) { + videoflags = FastestFlags(videoflags, width, height, video_bpp); + } else + if ( strcmp(argv[argc], "-hw") == 0 ) { + videoflags ^= SDL_HWSURFACE; + } else + if ( strcmp(argv[argc], "-flip") == 0 ) { + videoflags ^= SDL_DOUBLEBUF; + } else + if ( strcmp(argv[argc], "-debugflip") == 0 ) { + debug_flip ^= 1; + } else + if ( strcmp(argv[argc], "-fullscreen") == 0 ) { + videoflags ^= SDL_FULLSCREEN; + } else + if ( isdigit(argv[argc][0]) ) { + numsprites = atoi(argv[argc]); + } else { + fprintf(stderr, + "Usage: %s [-bpp N] [-hw] [-flip] [-fast] [-fullscreen] [numsprites]\n", + argv[0]); + quit(1); + } + } + + /* Set video mode */ + screen = SDL_SetVideoMode(width, height, video_bpp, videoflags); + if ( ! screen ) { + fprintf(stderr, "Couldn't set %dx%d video mode: %s\n", + width, height, SDL_GetError()); + quit(2); + } + + /* Load the sprite */ + if ( LoadSprite("icon.bmp") < 0 ) { + quit(1); + } + + /* Allocate memory for the sprite info */ + mem = (Uint8 *)malloc(4*sizeof(SDL_Rect)*numsprites); + if ( mem == NULL ) { + SDL_FreeSurface(sprite); + fprintf(stderr, "Out of memory!\n"); + quit(2); + } + sprite_rects = (SDL_Rect *)mem; + positions = sprite_rects; + sprite_rects += numsprites; + velocities = sprite_rects; + sprite_rects += numsprites; + sprite_w = sprite->w; + sprite_h = sprite->h; + srand(time(NULL)); + for ( i=0; iw - sprite_w); + positions[i].y = rand()%(screen->h - sprite_h); + positions[i].w = sprite->w; + positions[i].h = sprite->h; + velocities[i].x = 0; + velocities[i].y = 0; + while ( ! velocities[i].x && ! velocities[i].y ) { + velocities[i].x = (rand()%(MAX_SPEED*2+1))-MAX_SPEED; + velocities[i].y = (rand()%(MAX_SPEED*2+1))-MAX_SPEED; + } + } + background = SDL_MapRGB(screen->format, 0x00, 0x00, 0x00); + + /* Print out information about our surfaces */ + printf("Screen is at %d bits per pixel\n",screen->format->BitsPerPixel); + if ( (screen->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { + printf("Screen is in video memory\n"); + } else { + printf("Screen is in system memory\n"); + } + if ( (screen->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF ) { + printf("Screen has double-buffering enabled\n"); + } + if ( (sprite->flags & SDL_HWSURFACE) == SDL_HWSURFACE ) { + printf("Sprite is in video memory\n"); + } else { + printf("Sprite is in system memory\n"); + } + /* Run a sample blit to trigger blit acceleration */ + { SDL_Rect dst; + dst.x = 0; + dst.y = 0; + dst.w = sprite->w; + dst.h = sprite->h; + SDL_BlitSurface(sprite, NULL, screen, &dst); + SDL_FillRect(screen, &dst, background); + } + if ( (sprite->flags & SDL_HWACCEL) == SDL_HWACCEL ) { + printf("Sprite blit uses hardware acceleration\n"); + } + if ( (sprite->flags & SDL_RLEACCEL) == SDL_RLEACCEL ) { + printf("Sprite blit uses RLE acceleration\n"); + } + + /* Loop, blitting sprites and waiting for a keystroke */ + frames = 0; + then = SDL_GetTicks(); + done = 0; + sprites_visible = 0; + while ( !done ) { + /* Check for events */ + ++frames; + while ( SDL_PollEvent(&event) ) { + switch (event.type) { + case SDL_MOUSEBUTTONDOWN: + SDL_WarpMouse(screen->w/2, screen->h/2); + break; + case SDL_KEYDOWN: + /* Any keypress quits the app... */ + case SDL_QUIT: + done = 1; + break; + default: + break; + } + } + MoveSprites(screen, background); + } + SDL_FreeSurface(sprite); + free(mem); + + /* Print out some timing information */ + now = SDL_GetTicks(); + if ( now > then ) { + printf("%2.2f frames per second\n", + ((double)frames*1000)/(now-then)); + } + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/testtimer.c b/ws2010/gdi3/p5/SDL/test/testtimer.c new file mode 100644 index 00000000..95608c12 --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/testtimer.c @@ -0,0 +1,87 @@ + +/* Test program to check the resolution of the SDL timer on the current + platform +*/ + +#include +#include + +#include "SDL.h" + +#define DEFAULT_RESOLUTION 1 + +static int ticks = 0; + +static Uint32 SDLCALL ticktock(Uint32 interval) +{ + ++ticks; + return(interval); +} + +static Uint32 SDLCALL callback(Uint32 interval, void *param) +{ + printf("Timer %d : param = %d\n", interval, (int)(uintptr_t)param); + return interval; +} + +int main(int argc, char *argv[]) +{ + int desired; + SDL_TimerID t1, t2, t3; + + if ( SDL_Init(SDL_INIT_TIMER) < 0 ) { + fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); + return(1); + } + + /* Start the timer */ + desired = 0; + if ( argv[1] ) { + desired = atoi(argv[1]); + } + if ( desired == 0 ) { + desired = DEFAULT_RESOLUTION; + } + SDL_SetTimer(desired, ticktock); + + /* Wait 10 seconds */ + printf("Waiting 10 seconds\n"); + SDL_Delay(10*1000); + + /* Stop the timer */ + SDL_SetTimer(0, NULL); + + /* Print the results */ + if ( ticks ) { + fprintf(stderr, + "Timer resolution: desired = %d ms, actual = %f ms\n", + desired, (double)(10*1000)/ticks); + } + + /* Test multiple timers */ + printf("Testing multiple timers...\n"); + t1 = SDL_AddTimer(100, callback, (void*)1); + if(!t1) + fprintf(stderr,"Could not create timer 1: %s\n", SDL_GetError()); + t2 = SDL_AddTimer(50, callback, (void*)2); + if(!t2) + fprintf(stderr,"Could not create timer 2: %s\n", SDL_GetError()); + t3 = SDL_AddTimer(233, callback, (void*)3); + if(!t3) + fprintf(stderr,"Could not create timer 3: %s\n", SDL_GetError()); + + /* Wait 10 seconds */ + printf("Waiting 10 seconds\n"); + SDL_Delay(10*1000); + + printf("Removing timer 1 and waiting 5 more seconds\n"); + SDL_RemoveTimer(t1); + + SDL_Delay(5*1000); + + SDL_RemoveTimer(t2); + SDL_RemoveTimer(t3); + + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/testver.c b/ws2010/gdi3/p5/SDL/test/testver.c new file mode 100644 index 00000000..4f45ffe5 --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/testver.c @@ -0,0 +1,37 @@ + +/* Test program to compare the compile-time version of SDL with the linked + version of SDL +*/ + +#include +#include + +#include "SDL.h" + +int main(int argc, char *argv[]) +{ + SDL_version compiled; + + /* Initialize SDL */ + if ( SDL_Init(0) < 0 ) { + fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); + exit(1); + } +#ifdef DEBUG + fprintf(stderr, "SDL initialized\n"); +#endif +#if SDL_VERSION_ATLEAST(1, 2, 0) + printf("Compiled with SDL 1.2 or newer\n"); +#else + printf("Compiled with SDL older than 1.2\n"); +#endif + SDL_VERSION(&compiled); + printf("Compiled version: %d.%d.%d\n", + compiled.major, compiled.minor, compiled.patch); + printf("Linked version: %d.%d.%d\n", + SDL_Linked_Version()->major, + SDL_Linked_Version()->minor, + SDL_Linked_Version()->patch); + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/testvidinfo.c b/ws2010/gdi3/p5/SDL/test/testvidinfo.c new file mode 100644 index 00000000..bbafeb8b --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/testvidinfo.c @@ -0,0 +1,465 @@ + +/* Simple program -- figure out what kind of video display we have */ + +#include +#include +#include +#include + +#include "SDL.h" + +#define NUM_BLITS 10 +#define NUM_UPDATES 500 + +#define FLAG_MASK (SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | \ + SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCEL | \ + SDL_RLEACCELOK) + +void PrintFlags(Uint32 flags) +{ + printf("0x%8.8x", (flags & FLAG_MASK)); + if ( flags & SDL_HWSURFACE ) { + printf(" SDL_HWSURFACE"); + } else { + printf(" SDL_SWSURFACE"); + } + if ( flags & SDL_FULLSCREEN ) { + printf(" | SDL_FULLSCREEN"); + } + if ( flags & SDL_DOUBLEBUF ) { + printf(" | SDL_DOUBLEBUF"); + } + if ( flags & SDL_SRCCOLORKEY ) { + printf(" | SDL_SRCCOLORKEY"); + } + if ( flags & SDL_SRCALPHA ) { + printf(" | SDL_SRCALPHA"); + } + if ( flags & SDL_RLEACCEL ) { + printf(" | SDL_RLEACCEL"); + } + if ( flags & SDL_RLEACCELOK ) { + printf(" | SDL_RLEACCELOK"); + } +} + +int RunBlitTests(SDL_Surface *screen, SDL_Surface *bmp, int blitcount) +{ + int i, j; + int maxx; + int maxy; + SDL_Rect dst; + + maxx = (int)screen->w - bmp->w + 1; + maxy = (int)screen->h - bmp->h + 1; + for ( i = 0; i < NUM_UPDATES; ++i ) { + for ( j = 0; j < blitcount; ++j ) { + if ( maxx ) { + dst.x = rand() % maxx; + } else { + dst.x = 0; + } + if ( maxy ) { + dst.y = rand() % maxy; + } else { + dst.y = 0; + } + dst.w = bmp->w; + dst.h = bmp->h; + SDL_BlitSurface(bmp, NULL, screen, &dst); + } + SDL_Flip(screen); + } + + return i; +} + +int RunModeTests(SDL_Surface *screen) +{ + Uint32 then, now; + Uint32 frames; + float seconds; + int i; + Uint8 r, g, b; + SDL_Surface *bmp, *bmpcc, *tmp; + SDL_Event event; + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* First test fills and screen update speed */ + printf("Running color fill and fullscreen update test\n"); + then = SDL_GetTicks(); + frames = 0; + for ( i = 0; i < 256; ++i ) { + r = i; + g = 0; + b = 0; + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b)); + SDL_Flip(screen); + ++frames; + } + for ( i = 0; i < 256; ++i ) { + r = 0; + g = i; + b = 0; + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b)); + SDL_Flip(screen); + ++frames; + } + for ( i = 0; i < 256; ++i ) { + r = 0; + g = 0; + b = i; + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b)); + SDL_Flip(screen); + ++frames; + } + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames, seconds, (float)frames / seconds); + } else { + printf("%d fills and flips in zero seconds!n", frames); + } + + /* clear the screen after fill test */ + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); + SDL_Flip(screen); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* run the generic blit test */ + bmp = SDL_LoadBMP("sample.bmp"); + if ( ! bmp ) { + printf("Couldn't load sample.bmp: %s\n", SDL_GetError()); + return 0; + } + printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ", + bmp->w, bmp->h, bmp->format->BitsPerPixel); + PrintFlags(bmp->flags); + printf("\n"); + then = SDL_GetTicks(); + frames = RunBlitTests(screen, bmp, NUM_BLITS); + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds); + } else { + printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames); + } + + /* clear the screen after blit test */ + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); + SDL_Flip(screen); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* run the colorkeyed blit test */ + bmpcc = SDL_LoadBMP("sample.bmp"); + if ( ! bmpcc ) { + printf("Couldn't load sample.bmp: %s\n", SDL_GetError()); + return 0; + } + printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ", + bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel); + SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels); + + PrintFlags(bmpcc->flags); + printf("\n"); + then = SDL_GetTicks(); + frames = RunBlitTests(screen, bmpcc, NUM_BLITS); + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds); + } else { + printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames); + } + + /* clear the screen after cc blit test */ + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); + SDL_Flip(screen); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* run the generic blit test */ + tmp = bmp; + bmp = SDL_DisplayFormat(bmp); + SDL_FreeSurface(tmp); + if ( ! bmp ) { + printf("Couldn't convert sample.bmp: %s\n", SDL_GetError()); + return 0; + } + printf("Running display format blit test: %dx%d at %d bpp, flags: ", + bmp->w, bmp->h, bmp->format->BitsPerPixel); + PrintFlags(bmp->flags); + printf("\n"); + then = SDL_GetTicks(); + frames = RunBlitTests(screen, bmp, NUM_BLITS); + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds); + } else { + printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames); + } + + /* clear the screen after blit test */ + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); + SDL_Flip(screen); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* run the colorkeyed blit test */ + tmp = bmpcc; + bmpcc = SDL_DisplayFormat(bmpcc); + SDL_FreeSurface(tmp); + if ( ! bmpcc ) { + printf("Couldn't convert sample.bmp: %s\n", SDL_GetError()); + return 0; + } + printf("Running display format cc blit test: %dx%d at %d bpp, flags: ", + bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel); + PrintFlags(bmpcc->flags); + printf("\n"); + then = SDL_GetTicks(); + frames = RunBlitTests(screen, bmpcc, NUM_BLITS); + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds); + } else { + printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames); + } + + /* clear the screen after cc blit test */ + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); + SDL_Flip(screen); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* run the alpha blit test only if screen bpp>8 */ + if (bmp->format->BitsPerPixel>8) + { + SDL_FreeSurface(bmp); + bmp = SDL_LoadBMP("sample.bmp"); + SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */ + tmp = bmp; + bmp = SDL_DisplayFormat(bmp); + SDL_FreeSurface(tmp); + if ( ! bmp ) { + printf("Couldn't convert sample.bmp: %s\n", SDL_GetError()); + return 0; + } + printf("Running display format alpha blit test: %dx%d at %d bpp, flags: ", + bmp->w, bmp->h, bmp->format->BitsPerPixel); + PrintFlags(bmp->flags); + printf("\n"); + then = SDL_GetTicks(); + frames = RunBlitTests(screen, bmp, NUM_BLITS); + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds); + } else { + printf("%d alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames); + } + } + + /* clear the screen after alpha blit test */ + SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0)); + SDL_Flip(screen); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + + /* run the cc+alpha blit test only if screen bpp>8 */ + if (bmp->format->BitsPerPixel>8) + { + SDL_FreeSurface(bmpcc); + bmpcc = SDL_LoadBMP("sample.bmp"); + SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85); /* 85 - 33% alpha */ + SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels); + tmp = bmpcc; + bmpcc = SDL_DisplayFormat(bmpcc); + SDL_FreeSurface(tmp); + if ( ! bmpcc ) { + printf("Couldn't convert sample.bmp: %s\n", SDL_GetError()); + return 0; + } + printf("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ", + bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel); + PrintFlags(bmpcc->flags); + printf("\n"); + then = SDL_GetTicks(); + frames = RunBlitTests(screen, bmpcc, NUM_BLITS); + now = SDL_GetTicks(); + seconds = (float)(now - then) / 1000.0f; + if ( seconds > 0.0f ) { + printf("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds); + } else { + printf("%d cc+alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames); + } + } + + SDL_FreeSurface(bmpcc); + SDL_FreeSurface(bmp); + + while ( SDL_PollEvent(&event) ) { + if ( event.type == SDL_KEYDOWN ) + return 0; + } + return 1; +} + +void RunVideoTests() +{ + static const struct { + int w, h, bpp; + } mode_list[] = { + { 640, 480, 8 }, { 640, 480, 16 }, { 640, 480, 32 }, + { 800, 600, 8 }, { 800, 600, 16 }, { 800, 600, 32 }, + { 1024, 768, 8 }, { 1024, 768, 16 }, { 1024, 768, 32 } + }; + static const Uint32 flags[] = { + (SDL_SWSURFACE), + (SDL_SWSURFACE | SDL_FULLSCREEN), + (SDL_HWSURFACE | SDL_FULLSCREEN), + (SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF) + }; + int i, j; + SDL_Surface *screen; + + /* Test out several different video mode combinations */ + SDL_WM_SetCaption("SDL Video Benchmark", "vidtest"); + SDL_ShowCursor(0); + for ( i = 0; i < SDL_TABLESIZE(mode_list); ++i ) { + for ( j = 0; j < SDL_TABLESIZE(flags); ++j ) { + printf("===================================\n"); + printf("Setting video mode: %dx%d at %d bpp, flags: ", + mode_list[i].w, + mode_list[i].h, + mode_list[i].bpp); + PrintFlags(flags[j]); + printf("\n"); + screen = SDL_SetVideoMode(mode_list[i].w, + mode_list[i].h, + mode_list[i].bpp, + flags[j]); + if ( ! screen ) { + printf("Setting video mode failed: %s\n", SDL_GetError()); + continue; + } + if ( (screen->flags & FLAG_MASK) != flags[j] ) { + printf("Flags didn't match: "); + PrintFlags(screen->flags); + printf("\n"); + continue; + } + if ( ! RunModeTests(screen) ) { + return; + } + } + } +} + +int main(int argc, char *argv[]) +{ + const SDL_VideoInfo *info; + int i; + SDL_Rect **modes; + char driver[128]; + + if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { + fprintf(stderr, + "Couldn't initialize SDL: %s\n", SDL_GetError()); + exit(1); + } + if ( SDL_VideoDriverName(driver, sizeof(driver)) ) { + printf("Video driver: %s\n", driver); + } + info = SDL_GetVideoInfo(); + printf( +"Current display: %dx%d, %d bits-per-pixel\n", + info->current_w, info->current_h, info->vfmt->BitsPerPixel); + if ( info->vfmt->palette == NULL ) { + printf(" Red Mask = 0x%.8x\n", info->vfmt->Rmask); + printf(" Green Mask = 0x%.8x\n", info->vfmt->Gmask); + printf(" Blue Mask = 0x%.8x\n", info->vfmt->Bmask); + } + /* Print available fullscreen video modes */ + modes = SDL_ListModes(NULL, SDL_FULLSCREEN); + if ( modes == (SDL_Rect **)0 ) { + printf("No available fullscreen video modes\n"); + } else + if ( modes == (SDL_Rect **)-1 ) { + printf("No special fullscreen video modes\n"); + } else { + printf("Fullscreen video modes:\n"); + for ( i=0; modes[i]; ++i ) { + printf("\t%dx%dx%d\n", modes[i]->w, modes[i]->h, info->vfmt->BitsPerPixel); + } + } + if ( info->wm_available ) { + printf("A window manager is available\n"); + } + if ( info->hw_available ) { + printf("Hardware surfaces are available (%dK video memory)\n", + info->video_mem); + } + if ( info->blit_hw ) { + printf( +"Copy blits between hardware surfaces are accelerated\n"); + } + if ( info->blit_hw_CC ) { + printf( +"Colorkey blits between hardware surfaces are accelerated\n"); + } + if ( info->blit_hw_A ) { + printf( +"Alpha blits between hardware surfaces are accelerated\n"); + } + if ( info->blit_sw ) { + printf( +"Copy blits from software surfaces to hardware surfaces are accelerated\n"); + } + if ( info->blit_sw_CC ) { + printf( +"Colorkey blits from software surfaces to hardware surfaces are accelerated\n"); + } + if ( info->blit_sw_A ) { + printf( +"Alpha blits from software surfaces to hardware surfaces are accelerated\n"); + } + if ( info->blit_fill ) { + printf( +"Color fills on hardware surfaces are accelerated\n"); + } + + if ( argv[1] && (strcmp(argv[1], "-benchmark") == 0) ) { + RunVideoTests(); + } + + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/testwin.c b/ws2010/gdi3/p5/SDL/test/testwin.c new file mode 100644 index 00000000..261ea994 --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/testwin.c @@ -0,0 +1,377 @@ + +/* Bring up a window and play with it */ + +#include +#include +#include + +#define BENCHMARK_SDL + +#define NOTICE(X) printf("%s", X); + +#include "SDL.h" + +/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ +static void quit(int rc) +{ + SDL_Quit(); + exit(rc); +} + +void DrawPict(SDL_Surface *screen, char *bmpfile, + int speedy, int flip, int nofade) +{ + SDL_Surface *picture; + SDL_Rect dest, update; + int i, centered; + int ncolors; + SDL_Color *colors, *cmap; + + /* Load the image into a surface */ + if ( bmpfile == NULL ) { + bmpfile = "sample.bmp"; /* Sample image */ + } +fprintf(stderr, "Loading picture: %s\n", bmpfile); + picture = SDL_LoadBMP(bmpfile); + if ( picture == NULL ) { + fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, + SDL_GetError()); + return; + } + + /* Set the display colors -- on a hicolor display this is a no-op */ + if ( picture->format->palette ) { + ncolors = picture->format->palette->ncolors; + colors = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color)); + cmap = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color)); + memcpy(colors, picture->format->palette->colors, + ncolors*sizeof(SDL_Color)); + } else { + int r, g, b; + + /* Allocate 256 color palette */ + ncolors = 256; + colors = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color)); + cmap = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color)); + + /* Set a 3,3,2 color cube */ + for ( r=0; r<8; ++r ) { + for ( g=0; g<8; ++g ) { + for ( b=0; b<4; ++b ) { + i = ((r<<5)|(g<<2)|b); + colors[i].r = r<<5; + colors[i].g = g<<5; + colors[i].b = b<<6; + } + } + } + } +NOTICE("testwin: setting colors\n"); + if ( ! SDL_SetColors(screen, colors, 0, ncolors) && + (screen->format->palette != NULL) ) { + fprintf(stderr, +"Warning: Couldn't set all of the colors, but SDL will map the image\n" +" (colormap fading will suffer - try the -warp option)\n" + ); + } + + /* Set the screen to black (not really necessary) */ + if ( SDL_LockSurface(screen) == 0 ) { + Uint32 black; + Uint8 *pixels; + + black = SDL_MapRGB(screen->format, 0, 0, 0); + pixels = (Uint8 *)screen->pixels; + for ( i=0; ih; ++i ) { + memset(pixels, black, + screen->w*screen->format->BytesPerPixel); + pixels += screen->pitch; + } + SDL_UnlockSurface(screen); + SDL_UpdateRect(screen, 0, 0, 0, 0); + } + + /* Display the picture */ + if ( speedy ) { + SDL_Surface *displayfmt; + +fprintf(stderr, "Converting picture\n"); + displayfmt = SDL_DisplayFormat(picture); + if ( displayfmt == NULL ) { + fprintf(stderr, + "Couldn't convert image: %s\n", SDL_GetError()); + goto done; + } + SDL_FreeSurface(picture); + picture = displayfmt; + } + printf("(image surface located in %s memory)\n", + (picture->flags&SDL_HWSURFACE) ? "video" : "system"); + centered = (screen->w - picture->w)/2; + if ( centered < 0 ) { + centered = 0; + } + dest.y = (screen->h - picture->h)/2; + dest.w = picture->w; + dest.h = picture->h; +NOTICE("testwin: moving image\n"); + for ( i=0; i<=centered; ++i ) { + dest.x = i; + update = dest; + if ( SDL_BlitSurface(picture, NULL, screen, &update) < 0 ) { + fprintf(stderr, "Blit failed: %s\n", SDL_GetError()); + break; + } + if ( flip ) { + SDL_Flip(screen); + } else { + SDL_UpdateRects(screen, 1, &update); + } + } + +#ifdef SCREENSHOT + if ( SDL_SaveBMP(screen, "screen.bmp") < 0 ) + printf("Couldn't save screen: %s\n", SDL_GetError()); +#endif + +#ifndef BENCHMARK_SDL + /* Let it sit there for a while */ + SDL_Delay(5*1000); +#endif + /* Fade the colormap */ + if ( ! nofade ) { + int maxstep; + SDL_Color final; + SDL_Color palcolors[256]; + struct { + Sint16 r, g, b; + } cdist[256]; + +NOTICE("testwin: fading out...\n"); + memcpy(cmap, colors, ncolors*sizeof(SDL_Color)); + maxstep = 32-1; + final.r = 0xFF; + final.g = 0x00; + final.b = 0x00; + memcpy(palcolors, colors, ncolors*sizeof(SDL_Color)); + for ( i=0; i 1 ) { + if ( strcmp(argv[1], "-speedy") == 0 ) { + speedy = 1; + argv += 1; + argc -= 1; + } else + if ( strcmp(argv[1], "-nofade") == 0 ) { + nofade = 1; + argv += 1; + argc -= 1; + } else + if ( strcmp(argv[1], "-delay") == 0 ) { + if ( argv[2] ) { + delay = atoi(argv[2]); + argv += 2; + argc -= 2; + } else { + fprintf(stderr, + "The -delay option requires an argument\n"); + quit(1); + } + } else + if ( strcmp(argv[1], "-width") == 0 ) { + if ( argv[2] && ((w = atoi(argv[2])) > 0) ) { + argv += 2; + argc -= 2; + } else { + fprintf(stderr, + "The -width option requires an argument\n"); + quit(1); + } + } else + if ( strcmp(argv[1], "-height") == 0 ) { + if ( argv[2] && ((h = atoi(argv[2])) > 0) ) { + argv += 2; + argc -= 2; + } else { + fprintf(stderr, + "The -height option requires an argument\n"); + quit(1); + } + } else + if ( strcmp(argv[1], "-bpp") == 0 ) { + if ( argv[2] ) { + desired_bpp = atoi(argv[2]); + argv += 2; + argc -= 2; + } else { + fprintf(stderr, + "The -bpp option requires an argument\n"); + quit(1); + } + } else + if ( strcmp(argv[1], "-warp") == 0 ) { + video_flags |= SDL_HWPALETTE; + argv += 1; + argc -= 1; + } else + if ( strcmp(argv[1], "-hw") == 0 ) { + video_flags |= SDL_HWSURFACE; + argv += 1; + argc -= 1; + } else + if ( strcmp(argv[1], "-flip") == 0 ) { + video_flags |= SDL_DOUBLEBUF; + argv += 1; + argc -= 1; + } else + if ( strcmp(argv[1], "-fullscreen") == 0 ) { + video_flags |= SDL_FULLSCREEN; + argv += 1; + argc -= 1; + } else + break; + } + + /* Initialize the display */ + screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags); + if ( screen == NULL ) { + fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n", + w, h, desired_bpp, SDL_GetError()); + quit(1); + } + printf("Set%s %dx%dx%d mode\n", + screen->flags & SDL_FULLSCREEN ? " fullscreen" : "", + screen->w, screen->h, screen->format->BitsPerPixel); + printf("(video surface located in %s memory)\n", + (screen->flags&SDL_HWSURFACE) ? "video" : "system"); + if ( screen->flags & SDL_DOUBLEBUF ) { + printf("Double-buffering enabled\n"); + flip = 1; + } + + /* Set the window manager title bar */ + SDL_WM_SetCaption("SDL test window", "testwin"); + + /* Do all the drawing work */ +#ifdef BENCHMARK_SDL + then = SDL_GetTicks(); + DrawPict(screen, argv[1], speedy, flip, nofade); + now = SDL_GetTicks(); + printf("Time: %d milliseconds\n", now-then); +#else + DrawPict(screen, argv[1], speedy, flip, nofade); +#endif + SDL_Delay(delay*1000); + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/testwm.c b/ws2010/gdi3/p5/SDL/test/testwm.c new file mode 100644 index 00000000..9c3c0506 --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/testwm.c @@ -0,0 +1,443 @@ + +/* Test out the window manager interaction functions */ + +#include +#include +#include + +#include "SDL.h" + +/* Is the cursor visible? */ +static int visible = 1; + +static Uint8 video_bpp; +static Uint32 video_flags; + +/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ +static void quit(int rc) +{ + SDL_Quit(); + exit(rc); +} + +int SetVideoMode(int w, int h) +{ + SDL_Surface *screen; + int i; + Uint8 *buffer; + SDL_Color palette[256]; + + screen = SDL_SetVideoMode(w, h, video_bpp, video_flags); + if ( screen == NULL ) { + fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n", + w, h, video_bpp, SDL_GetError()); + return(-1); + } + printf("Running in %s mode\n", screen->flags & SDL_FULLSCREEN ? + "fullscreen" : "windowed"); + + /* Set the surface pixels and refresh! */ + for ( i=0; i<256; ++i ) { + palette[i].r = 255-i; + palette[i].g = 255-i; + palette[i].b = 255-i; + } + SDL_SetColors(screen, palette, 0, 256); + if ( SDL_LockSurface(screen) < 0 ) { + fprintf(stderr, "Couldn't lock display surface: %s\n", + SDL_GetError()); + return(-1); + } + buffer = (Uint8 *)screen->pixels; + for ( i=0; ih; ++i ) { + memset(buffer,(i*255)/screen->h, + screen->w*screen->format->BytesPerPixel); + buffer += screen->pitch; + } + SDL_UnlockSurface(screen); + SDL_UpdateRect(screen, 0, 0, 0, 0); + + return(0); +} + +SDL_Surface *LoadIconSurface(char *file, Uint8 **maskp) +{ + SDL_Surface *icon; + Uint8 *pixels; + Uint8 *mask; + int mlen, i, j; + + *maskp = NULL; + + /* Load the icon surface */ + icon = SDL_LoadBMP(file); + if ( icon == NULL ) { + fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError()); + return(NULL); + } + + /* Check width and height + if ( (icon->w%8) != 0 ) { + fprintf(stderr, "Icon width must be a multiple of 8!\n"); + SDL_FreeSurface(icon); + return(NULL); + } +*/ + + + if ( icon->format->palette == NULL ) { + fprintf(stderr, "Icon must have a palette!\n"); + SDL_FreeSurface(icon); + return(NULL); + } + + /* Set the colorkey */ + SDL_SetColorKey(icon, SDL_SRCCOLORKEY, *((Uint8 *)icon->pixels)); + + /* Create the mask */ + pixels = (Uint8 *)icon->pixels; + printf("Transparent pixel: (%d,%d,%d)\n", + icon->format->palette->colors[*pixels].r, + icon->format->palette->colors[*pixels].g, + icon->format->palette->colors[*pixels].b); + mlen = (icon->w*icon->h + 7) / 8; + mask = (Uint8 *)malloc(mlen); + if ( mask == NULL ) { + fprintf(stderr, "Out of memory!\n"); + SDL_FreeSurface(icon); + return(NULL); + } + memset(mask, 0, mlen); + for ( i=0; i < icon->h; i++) + for (j=0; j < icon->w; j++) { + int pindex = i * icon->pitch + j; + int mindex = i * icon->w + j; + if ( pixels[pindex] != *pixels ) + mask[mindex>>3] |= 1 << (7 - (mindex & 7)); + } + *maskp = mask; + return(icon); +} + +void HotKey_ToggleFullScreen(void) +{ + SDL_Surface *screen; + + screen = SDL_GetVideoSurface(); + if ( SDL_WM_ToggleFullScreen(screen) ) { + printf("Toggled fullscreen mode - now %s\n", + (screen->flags&SDL_FULLSCREEN) ? "fullscreen" : "windowed"); + } else { + printf("Unable to toggle fullscreen mode\n"); + video_flags ^= SDL_FULLSCREEN; + SetVideoMode(screen->w, screen->h); + } +} + +void HotKey_ToggleGrab(void) +{ + SDL_GrabMode mode; + + printf("Ctrl-G: toggling input grab!\n"); + mode = SDL_WM_GrabInput(SDL_GRAB_QUERY); + if ( mode == SDL_GRAB_ON ) { + printf("Grab was on\n"); + } else { + printf("Grab was off\n"); + } + mode = SDL_WM_GrabInput(mode ? SDL_GRAB_OFF : SDL_GRAB_ON); + if ( mode == SDL_GRAB_ON ) { + printf("Grab is now on\n"); + } else { + printf("Grab is now off\n"); + } +} + +void HotKey_Iconify(void) +{ + printf("Ctrl-Z: iconifying window!\n"); + SDL_WM_IconifyWindow(); +} + +void HotKey_Quit(void) +{ + SDL_Event event; + + printf("Posting internal quit request\n"); + event.type = SDL_USEREVENT; + SDL_PushEvent(&event); +} + +static void print_modifiers(void) +{ + int mod; + printf(" modifiers:"); + mod = SDL_GetModState(); + if(!mod) { + printf(" (none)"); + return; + } + if(mod & KMOD_LSHIFT) + printf(" LSHIFT"); + if(mod & KMOD_RSHIFT) + printf(" RSHIFT"); + if(mod & KMOD_LCTRL) + printf(" LCTRL"); + if(mod & KMOD_RCTRL) + printf(" RCTRL"); + if(mod & KMOD_LALT) + printf(" LALT"); + if(mod & KMOD_RALT) + printf(" RALT"); + if(mod & KMOD_LMETA) + printf(" LMETA"); + if(mod & KMOD_RMETA) + printf(" RMETA"); + if(mod & KMOD_NUM) + printf(" NUM"); + if(mod & KMOD_CAPS) + printf(" CAPS"); + if(mod & KMOD_MODE) + printf(" MODE"); +} + +static void PrintKey(const SDL_keysym *sym, int pressed) +{ + /* Print the keycode, name and state */ + if ( sym->sym ) { + printf("Key %s: %d-%s ", pressed ? "pressed" : "released", + sym->sym, SDL_GetKeyName(sym->sym)); + } else { + printf("Unknown Key (scancode = %d) %s ", sym->scancode, + pressed ? "pressed" : "released"); + } + + /* Print the translated character, if one exists */ + if ( sym->unicode ) { + /* Is it a control-character? */ + if ( sym->unicode < ' ' ) { + printf(" (^%c)", sym->unicode+'@'); + } else { +#ifdef UNICODE + printf(" (%c)", sym->unicode); +#else + /* This is a Latin-1 program, so only show 8-bits */ + if ( !(sym->unicode & 0xFF00) ) + printf(" (%c)", sym->unicode); + else + printf(" (0x%X)", sym->unicode); +#endif + } + } + print_modifiers(); + printf("\n"); +} + +int SDLCALL FilterEvents(const SDL_Event *event) +{ + static int reallyquit = 0; + + switch (event->type) { + + case SDL_ACTIVEEVENT: + /* See what happened */ + printf("App %s ", + event->active.gain ? "gained" : "lost"); + if ( event->active.state & SDL_APPACTIVE ) + printf("active "); + if ( event->active.state & SDL_APPINPUTFOCUS ) + printf("input "); + if ( event->active.state & SDL_APPMOUSEFOCUS ) + printf("mouse "); + printf("focus\n"); + + /* See if we are iconified or restored */ + if ( event->active.state & SDL_APPACTIVE ) { + printf("App has been %s\n", + event->active.gain ? + "restored" : "iconified"); + } + return(0); + + /* We want to toggle visibility on buttonpress */ + case SDL_MOUSEBUTTONDOWN: + case SDL_MOUSEBUTTONUP: + if ( event->button.state == SDL_PRESSED ) { + visible = !visible; + SDL_ShowCursor(visible); + } + printf("Mouse button %d has been %s\n", + event->button.button, + (event->button.state == SDL_PRESSED) ? + "pressed" : "released"); + return(0); + + /* Show relative mouse motion */ + case SDL_MOUSEMOTION: +#if 0 + printf("Mouse motion: {%d,%d} (%d,%d)\n", + event->motion.x, event->motion.y, + event->motion.xrel, event->motion.yrel); +#endif + return(0); + + case SDL_KEYDOWN: + PrintKey(&event->key.keysym, 1); + if ( event->key.keysym.sym == SDLK_ESCAPE ) { + HotKey_Quit(); + } + if ( (event->key.keysym.sym == SDLK_g) && + (event->key.keysym.mod & KMOD_CTRL) ) { + HotKey_ToggleGrab(); + } + if ( (event->key.keysym.sym == SDLK_z) && + (event->key.keysym.mod & KMOD_CTRL) ) { + HotKey_Iconify(); + } + if ( (event->key.keysym.sym == SDLK_RETURN) && + (event->key.keysym.mod & KMOD_ALT) ) { + HotKey_ToggleFullScreen(); + } + return(0); + + case SDL_KEYUP: + PrintKey(&event->key.keysym, 0); + return(0); + + /* Pass the video resize event through .. */ + case SDL_VIDEORESIZE: + return(1); + + /* This is important! Queue it if we want to quit. */ + case SDL_QUIT: + if ( ! reallyquit ) { + reallyquit = 1; + printf("Quit requested\n"); + return(0); + } + printf("Quit demanded\n"); + return(1); + + /* This will never happen because events queued directly + to the event queue are not filtered. + */ + case SDL_USEREVENT: + return(1); + + /* Drop all other events */ + default: + return(0); + } +} + +int main(int argc, char *argv[]) +{ + SDL_Event event; + char *title; + SDL_Surface *icon; + Uint8 *icon_mask; + int parsed; + int w, h; + + if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { + fprintf(stderr, + "Couldn't initialize SDL: %s\n", SDL_GetError()); + return(1); + } + + /* Check command line arguments */ + w = 640; + h = 480; + video_bpp = 8; + video_flags = SDL_SWSURFACE; + parsed = 1; + while ( parsed ) { + if ( (argc >= 2) && (strcmp(argv[1], "-fullscreen") == 0) ) { + video_flags |= SDL_FULLSCREEN; + argc -= 1; + argv += 1; + } else + if ( (argc >= 2) && (strcmp(argv[1], "-resize") == 0) ) { + video_flags |= SDL_RESIZABLE; + argc -= 1; + argv += 1; + } else + if ( (argc >= 2) && (strcmp(argv[1], "-noframe") == 0) ) { + video_flags |= SDL_NOFRAME; + argc -= 1; + argv += 1; + } else + if ( (argc >= 3) && (strcmp(argv[1], "-width") == 0) ) { + w = atoi(argv[2]); + argc -= 2; + argv += 2; + } else + if ( (argc >= 3) && (strcmp(argv[1], "-height") == 0) ) { + h = atoi(argv[2]); + argc -= 2; + argv += 2; + } else + if ( (argc >= 3) && (strcmp(argv[1], "-bpp") == 0) ) { + video_bpp = atoi(argv[2]); + argc -= 2; + argv += 2; + } else { + parsed = 0; + } + } + + /* Set the icon -- this must be done before the first mode set */ + icon = LoadIconSurface("icon.bmp", &icon_mask); + if ( icon != NULL ) { + SDL_WM_SetIcon(icon, icon_mask); + } + if ( icon_mask != NULL ) + free(icon_mask); + + /* Set the title bar */ + if ( argv[1] == NULL ) + title = "Testing 1.. 2.. 3..."; + else + title = argv[1]; + SDL_WM_SetCaption(title, "testwm"); + + /* See if it's really set */ + SDL_WM_GetCaption(&title, NULL); + if ( title ) + printf("Title was set to: %s\n", title); + else + printf("No window title was set!\n"); + + /* Initialize the display */ + if ( SetVideoMode(w, h) < 0 ) { + quit(1); + } + + /* Set an event filter that discards everything but QUIT */ + SDL_SetEventFilter(FilterEvents); + + /* Loop, waiting for QUIT */ + while ( SDL_WaitEvent(&event) ) { + switch (event.type) { + case SDL_VIDEORESIZE: + printf("Got a resize event: %dx%d\n", + event.resize.w, event.resize.h); + SetVideoMode(event.resize.w, event.resize.h); + break; + case SDL_USEREVENT: + printf("Handling internal quit request\n"); + /* Fall through to the quit handler */ + case SDL_QUIT: + printf("Bye bye..\n"); + quit(0); + default: + /* This should never happen */ + printf("Warning: Event %d wasn't filtered\n", + event.type); + break; + } + } + printf("SDL_WaitEvent() error: %s\n", SDL_GetError()); + SDL_Quit(); + return(255); +} diff --git a/ws2010/gdi3/p5/SDL/test/threadwin.c b/ws2010/gdi3/p5/SDL/test/threadwin.c new file mode 100644 index 00000000..c704b30d --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/threadwin.c @@ -0,0 +1,338 @@ + +/* Test out the multi-threaded event handling functions */ + +#include +#include +#include + +#include "SDL.h" +#include "SDL_thread.h" + +/* Are we done yet? */ +static int done = 0; + +/* Is the cursor visible? */ +static int visible = 1; + +/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ +static void quit(int rc) +{ + SDL_Quit(); + exit(rc); +} + +SDL_Surface *LoadIconSurface(char *file, Uint8 **maskp) +{ + SDL_Surface *icon; + Uint8 *pixels; + Uint8 *mask; + int mlen, i; + + *maskp = NULL; + + /* Load the icon surface */ + icon = SDL_LoadBMP(file); + if ( icon == NULL ) { + fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError()); + return(NULL); + } + + /* Check width and height */ + if ( (icon->w%8) != 0 ) { + fprintf(stderr, "Icon width must be a multiple of 8!\n"); + SDL_FreeSurface(icon); + return(NULL); + } + if ( icon->format->palette == NULL ) { + fprintf(stderr, "Icon must have a palette!\n"); + SDL_FreeSurface(icon); + return(NULL); + } + + /* Set the colorkey */ + SDL_SetColorKey(icon, SDL_SRCCOLORKEY, *((Uint8 *)icon->pixels)); + + /* Create the mask */ + pixels = (Uint8 *)icon->pixels; + printf("Transparent pixel: (%d,%d,%d)\n", + icon->format->palette->colors[*pixels].r, + icon->format->palette->colors[*pixels].g, + icon->format->palette->colors[*pixels].b); + mlen = icon->w*icon->h; + mask = (Uint8 *)malloc(mlen/8); + if ( mask == NULL ) { + fprintf(stderr, "Out of memory!\n"); + SDL_FreeSurface(icon); + return(NULL); + } + memset(mask, 0, mlen/8); + for ( i=0; itype) { + + case SDL_ACTIVEEVENT: + /* See what happened */ + printf("App %s ", + event->active.gain ? "gained" : "lost"); + if ( event->active.state & SDL_APPACTIVE ) + printf("active "); + if ( event->active.state & SDL_APPMOUSEFOCUS ) + printf("mouse "); + if ( event->active.state & SDL_APPINPUTFOCUS ) + printf("input "); + printf("focus\n"); + + /* See if we are iconified or restored */ + if ( event->active.state & SDL_APPACTIVE ) { + printf("App has been %s\n", + event->active.gain ? + "restored" : "iconified"); + } + return(0); + + /* This is important! Queue it if we want to quit. */ + case SDL_QUIT: + if ( ! reallyquit ) { + reallyquit = 1; + printf("Quit requested\n"); + return(0); + } + printf("Quit demanded\n"); + return(1); + + /* Mouse and keyboard events go to threads */ + case SDL_MOUSEMOTION: + case SDL_MOUSEBUTTONDOWN: + case SDL_MOUSEBUTTONUP: + case SDL_KEYDOWN: + case SDL_KEYUP: + return(1); + + /* Drop all other events */ + default: + return(0); + } +} + +int SDLCALL HandleMouse(void *unused) +{ + SDL_Event events[10]; + int i, found; + Uint32 mask; + + /* Handle mouse events here */ + mask = (SDL_MOUSEMOTIONMASK|SDL_MOUSEBUTTONDOWNMASK|SDL_MOUSEBUTTONUPMASK); + while ( ! done ) { + found = SDL_PeepEvents(events, 10, SDL_GETEVENT, mask); + for ( i=0; i to quit the app */ + if ( events[i].key.keysym.sym == SDLK_ESCAPE ) { + done = 1; + } + + /* skip events now that aren't KEYUPs... */ + if (events[i].key.state == SDL_PRESSED) + break; + + if ( events[i].key.keysym.sym == SDLK_f ) { + int rc = 0; + printf("attempting to toggle fullscreen...\n"); + rc = SDL_WM_ToggleFullScreen(SDL_GetVideoSurface()); + printf("SDL_WM_ToggleFullScreen returned %d.\n", rc); + } + + if ( events[i].key.keysym.sym == SDLK_g ) { + SDL_GrabMode m; + m = SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_ON ? + SDL_GRAB_OFF : SDL_GRAB_ON; + printf("attempting to toggle input grab to %s...\n", + m == SDL_GRAB_ON ? "ON" : "OFF"); + SDL_WM_GrabInput(m); + printf("attempt finished.\n"); + } + + break; + } + } + /* Give up some CPU to allow events to arrive */ + SDL_Delay(20); + } + return(0); +} + +int main(int argc, char *argv[]) +{ + SDL_Surface *screen; + SDL_Surface *icon; + Uint8 *icon_mask; + int i, parsed; + Uint8 *buffer; + SDL_Color palette[256]; + Uint32 init_flags; + Uint8 video_bpp; + Uint32 video_flags; + SDL_Thread *mouse_thread; + SDL_Thread *keybd_thread; + + /* Set the options, based on command line arguments */ + init_flags = SDL_INIT_VIDEO; + video_bpp = 8; + video_flags = SDL_SWSURFACE; + parsed = 1; + while ( parsed ) { + /* If the threaded option is enabled, and the SDL library hasn't + been compiled with threaded events enabled, then the mouse and + keyboard won't respond. + */ + if ( (argc >= 2) && (strcmp(argv[1], "-threaded") == 0) ) { + init_flags |= SDL_INIT_EVENTTHREAD; + argc -= 1; + argv += 1; + printf("Running with threaded events\n"); + } else + if ( (argc >= 2) && (strcmp(argv[1], "-fullscreen") == 0) ) { + video_flags |= SDL_FULLSCREEN; + argc -= 1; + argv += 1; + } else + if ( (argc >= 3) && (strcmp(argv[1], "-bpp") == 0) ) { + video_bpp = atoi(argv[2]); + argc -= 2; + argv += 2; + } else { + parsed = 0; + } + } + + /* Initialize SDL with the requested flags */ + if ( SDL_Init(init_flags) < 0 ) { + fprintf(stderr, + "Couldn't initialize SDL: %s\n", SDL_GetError()); + return(1); + } + + /* Set the icon -- this must be done before the first mode set */ + icon = LoadIconSurface("icon.bmp", &icon_mask); + if ( icon != NULL ) { + SDL_WM_SetIcon(icon, icon_mask); + } + if ( icon_mask != NULL ) + free(icon_mask); + + /* Initialize the display */ + screen = SDL_SetVideoMode(640, 480, video_bpp, video_flags); + if ( screen == NULL ) { + fprintf(stderr, "Couldn't set 640x480x%d video mode: %s\n", + video_bpp, SDL_GetError()); + quit(1); + } + printf("Running in %s mode\n", screen->flags & SDL_FULLSCREEN ? + "fullscreen" : "windowed"); + + /* Enable printable characters */ + SDL_EnableUNICODE(1); + + /* Set an event filter that discards everything but QUIT */ + SDL_SetEventFilter(FilterEvents); + + /* Create the event handling threads */ + mouse_thread = SDL_CreateThread(HandleMouse, NULL); + keybd_thread = SDL_CreateThread(HandleKeyboard, NULL); + + /* Set the surface pixels and refresh! */ + for ( i=0; i<256; ++i ) { + palette[i].r = 255-i; + palette[i].g = 255-i; + palette[i].b = 255-i; + } + SDL_SetColors(screen, palette, 0, 256); + if ( SDL_LockSurface(screen) < 0 ) { + fprintf(stderr, "Couldn't lock display surface: %s\n", + SDL_GetError()); + quit(2); + } + buffer = (Uint8 *)screen->pixels; + for ( i=0; ih; ++i ) { + memset(buffer,(i*255)/screen->h, + screen->w*screen->format->BytesPerPixel); + buffer += screen->pitch; + } + SDL_UnlockSurface(screen); + SDL_UpdateRect(screen, 0, 0, 0, 0); + + /* Loop, waiting for QUIT */ + while ( ! done ) { + if ( ! (init_flags & SDL_INIT_EVENTTHREAD) ) { + SDL_PumpEvents(); /* Needed when event thread is off */ + } + if ( SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, SDL_QUITMASK) ) { + done = 1; + } + /* Give up some CPU so the events can accumulate */ + SDL_Delay(20); + } + SDL_WaitThread(mouse_thread, NULL); + SDL_WaitThread(keybd_thread, NULL); + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/torturethread.c b/ws2010/gdi3/p5/SDL/test/torturethread.c new file mode 100644 index 00000000..cb18954d --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/torturethread.c @@ -0,0 +1,91 @@ + +/* Simple test of the SDL threading code */ + +#include +#include +#include +#include + +#include "SDL.h" +#include "SDL_thread.h" + +#define NUMTHREADS 10 + +static char volatile time_for_threads_to_die[NUMTHREADS]; + +/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ +static void quit(int rc) +{ + SDL_Quit(); + exit(rc); +} + +int SDLCALL SubThreadFunc(void *data) { + while(! *(int volatile *)data) { + ; /*SDL_Delay(10);*/ /* do nothing */ + } + return 0; +} + +int SDLCALL ThreadFunc(void *data) { + SDL_Thread *sub_threads[NUMTHREADS]; + int flags[NUMTHREADS]; + int i; + int tid = (int)(uintptr_t)data; + + fprintf(stderr, "Creating Thread %d\n", tid); + + for(i = 0; i < NUMTHREADS; i++) { + flags[i] = 0; + sub_threads[i] = SDL_CreateThread(SubThreadFunc, &flags[i]); + } + + printf("Thread '%d' waiting for signal\n", tid); + while(time_for_threads_to_die[tid] != 1) { + ; /* do nothing */ + } + + printf("Thread '%d' sending signals to subthreads\n", tid); + for(i = 0; i < NUMTHREADS; i++) { + flags[i] = 1; + SDL_WaitThread(sub_threads[i], NULL); + } + + printf("Thread '%d' exiting!\n", tid); + + return 0; +} + +int main(int argc, char *argv[]) +{ + SDL_Thread *threads[NUMTHREADS]; + int i; + + /* Load the SDL library */ + if ( SDL_Init(0) < 0 ) { + fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError()); + return(1); + } + + signal(SIGSEGV, SIG_DFL); + for(i = 0; i < NUMTHREADS; i++) { + time_for_threads_to_die[i] = 0; + threads[i] = SDL_CreateThread(ThreadFunc, (void *)(uintptr_t)i); + + if ( threads[i] == NULL ) { + fprintf(stderr, + "Couldn't create thread: %s\n", SDL_GetError()); + quit(1); + } + } + + for(i = 0; i < NUMTHREADS; i++) { + time_for_threads_to_die[i] = 1; + } + + for(i = 0; i < NUMTHREADS; i++) { + SDL_WaitThread(threads[i], NULL); + } + SDL_Quit(); + return(0); +} diff --git a/ws2010/gdi3/p5/SDL/test/utf8.txt b/ws2010/gdi3/p5/SDL/test/utf8.txt new file mode 100644 index 00000000..aab22f1d --- /dev/null +++ b/ws2010/gdi3/p5/SDL/test/utf8.txt @@ -0,0 +1,287 @@ +UTF-8 decoder capability and stress test +---------------------------------------- + +Markus Kuhn - 2003-02-19 + +This test file can help you examine, how your UTF-8 decoder handles +various types of correct, malformed, or otherwise interesting UTF-8 +sequences. This file is not meant to be a conformance test. It does +not prescribes any particular outcome and therefore there is no way to +"pass" or "fail" this test file, even though the texts suggests a +preferable decoder behaviour at some places. The aim is instead to +help you think about and test the behaviour of your UTF-8 on a +systematic collection of unusual inputs. Experience so far suggests +that most first-time authors of UTF-8 decoders find at least one +serious problem in their decoder by using this file. + +The test lines below cover boundary conditions, malformed UTF-8 +sequences as well as correctly encoded UTF-8 sequences of Unicode code +points that should never occur in a correct UTF-8 file. + +According to ISO 10646-1:2000, sections D.7 and 2.3c, a device +receiving UTF-8 shall interpret a "malformed sequence in the same way +that it interprets a character that is outside the adopted subset" and +"characters that are not within the adopted subset shall be indicated +to the user" by a receiving device. A quite commonly used approach in +UTF-8 decoders is to replace any malformed UTF-8 sequence by a +replacement character (U+FFFD), which looks a bit like an inverted +question mark, or a similar symbol. It might be a good idea to +visually distinguish a malformed UTF-8 sequence from a correctly +encoded Unicode character that is just not available in the current +font but otherwise fully legal, even though ISO 10646-1 doesn't +mandate this. In any case, just ignoring malformed sequences or +unavailable characters does not conform to ISO 10646, will make +debugging more difficult, and can lead to user confusion. + +Please check, whether a malformed UTF-8 sequence is (1) represented at +all, (2) represented by exactly one single replacement character (or +equivalent signal), and (3) the following quotation mark after an +illegal UTF-8 sequence is correctly displayed, i.e. proper +resynchronization takes place immageately after any malformed +sequence. This file says "THE END" in the last line, so if you don't +see that, your decoder crashed somehow before, which should always be +cause for concern. + +All lines in this file are exactly 79 characters long (plus the line +feed). In addition, all lines end with "|", except for the two test +lines 2.1.1 and 2.2.1, which contain non-printable ASCII controls +U+0000 and U+007F. If you display this file with a fixed-width font, +these "|" characters should all line up in column 79 (right margin). +This allows you to test quickly, whether your UTF-8 decoder finds the +correct number of characters in every line, that is whether each +malformed sequences is replaced by a single replacement character. + +Note that as an alternative to the notion of malformed sequence used +here, it is also a perfectly acceptable (and in some situations even +preferable) solution to represent each individual byte of a malformed +sequence by a replacement character. If you follow this strategy in +your decoder, then please ignore the "|" column. + + +Here come the tests: | + | +1 Some correct UTF-8 text | + | +(The codepoints for this test are: | + U+03BA U+1F79 U+03C3 U+03BC U+03B5 --ryan.) | + | +You should see the Greek word 'kosme': "κόσμε" | + | + | +2 Boundary condition test cases | + | +2.1 First possible sequence of a certain length | + | +(byte zero skipped...there's a null added at the end of the test. --ryan.) | + | +2.1.2 2 bytes (U-00000080): "€" | +2.1.3 3 bytes (U-00000800): "ࠀ" | +2.1.4 4 bytes (U-00010000): "𐀀" | + | +(5 and 6 byte sequences were made illegal in rfc3629. --ryan.) | +2.1.5 5 bytes (U-00200000): "" | +2.1.6 6 bytes (U-04000000): "" | + | +2.2 Last possible sequence of a certain length | + | +2.2.1 1 byte (U-0000007F): "" | +2.2.2 2 bytes (U-000007FF): "߿" | + | +(Section 5.3.2 below calls this illegal. --ryan.) | +2.2.3 3 bytes (U-0000FFFF): "￿" | + | +(5 and 6 bytes sequences, and 4 bytes sequences > 0x10FFFF were made illegal | + in rfc3629, so these next three should be replaced with a invalid | + character codepoint. --ryan.) | +2.2.4 4 bytes (U-001FFFFF): "" | +2.2.5 5 bytes (U-03FFFFFF): "" | +2.2.6 6 bytes (U-7FFFFFFF): "" | + | +2.3 Other boundary conditions | + | +2.3.1 U-0000D7FF = ed 9f bf = "퟿" | +2.3.2 U-0000E000 = ee 80 80 = "" | +2.3.3 U-0000FFFD = ef bf bd = "�" | +2.3.4 U-0010FFFF = f4 8f bf bf = "􏿿" | + | +(This one is bogus in rfc3629. --ryan.) | +2.3.5 U-00110000 = f4 90 80 80 = "" | + | +3 Malformed sequences | + | +3.1 Unexpected continuation bytes | + | +Each unexpected continuation byte should be separately signalled as a | +malformed sequence of its own. | + | +3.1.1 First continuation byte 0x80: "" | +3.1.2 Last continuation byte 0xbf: "" | + | +3.1.3 2 continuation bytes: "" | +3.1.4 3 continuation bytes: "" | +3.1.5 4 continuation bytes: "" | +3.1.6 5 continuation bytes: "" | +3.1.7 6 continuation bytes: "" | +3.1.8 7 continuation bytes: "" | + | +3.1.9 Sequence of all 64 possible continuation bytes (0x80-0xbf): | + | + " | + | + | + " | + | +3.2 Lonely start characters | + | +3.2.1 All 32 first bytes of 2-byte sequences (0xc0-0xdf), | + each followed by a space character: | + | + " | + " | + | +3.2.2 All 16 first bytes of 3-byte sequences (0xe0-0xef), | + each followed by a space character: | + | + " " | + | +3.2.3 All 8 first bytes of 4-byte sequences (0xf0-0xf7), | + each followed by a space character: | + | + " " | + | +3.2.4 All 4 first bytes of 5-byte sequences (0xf8-0xfb), | + each followed by a space character: | + | + " " | + | +3.2.5 All 2 first bytes of 6-byte sequences (0xfc-0xfd), | + each followed by a space character: | + | + " " | + | +3.3 Sequences with last continuation byte missing | + | +All bytes of an incomplete sequence should be signalled as a single | +malformed sequence, i.e., you should see only a single replacement | +character in each of the next 10 tests. (Characters as in section 2) | + | +3.3.1 2-byte sequence with last byte missing (U+0000): "" | +3.3.2 3-byte sequence with last byte missing (U+0000): "" | +3.3.3 4-byte sequence with last byte missing (U+0000): "" | +3.3.4 5-byte sequence with last byte missing (U+0000): "" | +3.3.5 6-byte sequence with last byte missing (U+0000): "" | +3.3.6 2-byte sequence with last byte missing (U-000007FF): "" | +3.3.7 3-byte sequence with last byte missing (U-0000FFFF): "" | +3.3.8 4-byte sequence with last byte missing (U-001FFFFF): "" | +3.3.9 5-byte sequence with last byte missing (U-03FFFFFF): "" | +3.3.10 6-byte sequence with last byte missing (U-7FFFFFFF): "" | + | +3.4 Concatenation of incomplete sequences | + | +All the 10 sequences of 3.3 concatenated, you should see 10 malformed | +sequences being signalled: | + | + "" | + | +3.5 Impossible bytes | + | +The following two bytes cannot appear in a correct UTF-8 string | + | +3.5.1 fe = "" | +3.5.2 ff = "" | +3.5.3 fe fe ff ff = "" | + | +4 Overlong sequences | + | +The following sequences are not malformed according to the letter of | +the Unicode 2.0 standard. However, they are longer then necessary and | +a correct UTF-8 encoder is not allowed to produce them. A "safe UTF-8 | +decoder" should reject them just like malformed sequences for two | +reasons: (1) It helps to debug applications if overlong sequences are | +not treated as valid representations of characters, because this helps | +to spot problems more quickly. (2) Overlong sequences provide | +alternative representations of characters, that could maliciously be | +used to bypass filters that check only for ASCII characters. For | +instance, a 2-byte encoded line feed (LF) would not be caught by a | +line counter that counts only 0x0a bytes, but it would still be | +processed as a line feed by an unsafe UTF-8 decoder later in the | +pipeline. From a security point of view, ASCII compatibility of UTF-8 | +sequences means also, that ASCII characters are *only* allowed to be | +represented by ASCII bytes in the range 0x00-0x7f. To ensure this | +aspect of ASCII compatibility, use only "safe UTF-8 decoders" that | +reject overlong UTF-8 sequences for which a shorter encoding exists. | + | +4.1 Examples of an overlong ASCII character | + | +With a safe UTF-8 decoder, all of the following five overlong | +representations of the ASCII character slash ("/") should be rejected | +like a malformed UTF-8 sequence, for instance by substituting it with | +a replacement character. If you see a slash below, you do not have a | +safe UTF-8 decoder! | + | +4.1.1 U+002F = c0 af = "" | +4.1.2 U+002F = e0 80 af = "" | +4.1.3 U+002F = f0 80 80 af = "" | +4.1.4 U+002F = f8 80 80 80 af = "" | +4.1.5 U+002F = fc 80 80 80 80 af = "" | + | +4.2 Maximum overlong sequences | + | +Below you see the highest Unicode value that is still resulting in an | +overlong sequence if represented with the given number of bytes. This | +is a boundary test for safe UTF-8 decoders. All five characters should | +be rejected like malformed UTF-8 sequences. | + | +4.2.1 U-0000007F = c1 bf = "" | +4.2.2 U-000007FF = e0 9f bf = "" | +4.2.3 U-0000FFFF = f0 8f bf bf = "" | +4.2.4 U-001FFFFF = f8 87 bf bf bf = "" | +4.2.5 U-03FFFFFF = fc 83 bf bf bf bf = "" | + | +4.3 Overlong representation of the NUL character | + | +The following five sequences should also be rejected like malformed | +UTF-8 sequences and should not be treated like the ASCII NUL | +character. | + | +4.3.1 U+0000 = c0 80 = "" | +4.3.2 U+0000 = e0 80 80 = "" | +4.3.3 U+0000 = f0 80 80 80 = "" | +4.3.4 U+0000 = f8 80 80 80 80 = "" | +4.3.5 U+0000 = fc 80 80 80 80 80 = "" | + | +5 Illegal code positions | + | +The following UTF-8 sequences should be rejected like malformed | +sequences, because they never represent valid ISO 10646 characters and | +a UTF-8 decoder that accepts them might introduce security problems | +comparable to overlong UTF-8 sequences. | + | +5.1 Single UTF-16 surrogates | + | +5.1.1 U+D800 = ed a0 80 = "" | +5.1.2 U+DB7F = ed ad bf = "" | +5.1.3 U+DB80 = ed ae 80 = "" | +5.1.4 U+DBFF = ed af bf = "" | +5.1.5 U+DC00 = ed b0 80 = "" | +5.1.6 U+DF80 = ed be 80 = "" | +5.1.7 U+DFFF = ed bf bf = "" | + | +5.2 Paired UTF-16 surrogates | + | +5.2.1 U+D800 U+DC00 = ed a0 80 ed b0 80 = "" | +5.2.2 U+D800 U+DFFF = ed a0 80 ed bf bf = "" | +5.2.3 U+DB7F U+DC00 = ed ad bf ed b0 80 = "" | +5.2.4 U+DB7F U+DFFF = ed ad bf ed bf bf = "" | +5.2.5 U+DB80 U+DC00 = ed ae 80 ed b0 80 = "" | +5.2.6 U+DB80 U+DFFF = ed ae 80 ed bf bf = "" | +5.2.7 U+DBFF U+DC00 = ed af bf ed b0 80 = "" | +5.2.8 U+DBFF U+DFFF = ed af bf ed bf bf = "" | + | +5.3 Other illegal code positions | + | +5.3.1 U+FFFE = ef bf be = "￾" | +5.3.2 U+FFFF = ef bf bf = "￿" | + | +THE END | + diff --git a/ws2010/gdi3/p5/lib/libSDL.a b/ws2010/gdi3/p5/lib/libSDL.a new file mode 100644 index 00000000..362ebbb1 Binary files /dev/null and b/ws2010/gdi3/p5/lib/libSDL.a differ diff --git a/ws2010/gdi3/p5/lib/libSDL.la b/ws2010/gdi3/p5/lib/libSDL.la new file mode 100644 index 00000000..2ff62190 --- /dev/null +++ b/ws2010/gdi3/p5/lib/libSDL.la @@ -0,0 +1,41 @@ +# libSDL.la - a libtool library file +# Generated by ltmain.sh (GNU libtool) 2.2.6 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='libSDL-1.2.so.0' + +# Names of this library. +library_names='libSDL-1.2.so.0.11.3 libSDL-1.2.so.0 libSDL.so' + +# The name of the static archive. +old_library='libSDL.a' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs=' -lm -ldl -lpthread' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libSDL. +current=11 +age=11 +revision=3 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='/usr/lib' diff --git a/ws2010/gdi3/p5/lib/libSDL_ttf.so b/ws2010/gdi3/p5/lib/libSDL_ttf.so new file mode 100644 index 00000000..df16de37 Binary files /dev/null and b/ws2010/gdi3/p5/lib/libSDL_ttf.so differ diff --git a/ws2010/gdi3/p5/lib/libSDLmain.a b/ws2010/gdi3/p5/lib/libSDLmain.a new file mode 100644 index 00000000..cfba7ec3 Binary files /dev/null and b/ws2010/gdi3/p5/lib/libSDLmain.a differ diff --git a/ws2010/gdi3/p5/lib/libdirect-1.2.so.9 b/ws2010/gdi3/p5/lib/libdirect-1.2.so.9 new file mode 100644 index 00000000..fbe2d611 Binary files /dev/null and b/ws2010/gdi3/p5/lib/libdirect-1.2.so.9 differ diff --git a/ws2010/gdi3/p5/lib/libdirectfb-1.2.so.9 b/ws2010/gdi3/p5/lib/libdirectfb-1.2.so.9 new file mode 100644 index 00000000..76b77716 Binary files /dev/null and b/ws2010/gdi3/p5/lib/libdirectfb-1.2.so.9 differ diff --git a/ws2010/gdi3/p5/lib/libfusion-1.2.so.9 b/ws2010/gdi3/p5/lib/libfusion-1.2.so.9 new file mode 100644 index 00000000..1b8d84ea Binary files /dev/null and b/ws2010/gdi3/p5/lib/libfusion-1.2.so.9 differ diff --git a/ws2010/gdi3/p5/mandelbrot_vorgabe.cpp b/ws2010/gdi3/p5/mandelbrot_vorgabe.cpp new file mode 100644 index 00000000..13bcbbd8 --- /dev/null +++ b/ws2010/gdi3/p5/mandelbrot_vorgabe.cpp @@ -0,0 +1,79 @@ +#include +#include + +using namespace std; + +#include "MandelbrotSimple.class.h" +#include "MandelbrotOMP.class.h" +#include "MandelbrotPOSIX.class.h" +#include "Painter.class.cpp" + + //#include // POSIX-threads + +static const int ASCII_WIDTH = 50; +static const int ASCII_HEIGHT = 35; +static const int PIXEL_WIDTH = 1024; +static const int PIXEL_HEIGHT = 768; + +/* + * check arguments, create all necessary objects + */ +int main(int argc, char *argv[]) +{ + + if (argc<6) + { + printf("wrong number of arguments:\n1. number of iterations\n2. output mode [0 = disabled; 1 = ASCII; 2 = Graphic]\n3. OpenMP -> Number of threads\n4. Multithreading [0 = POSIX-Threads; 1 = OpenMP]\n5. SSE [0 = No SSE; 1 = SSE]\n"); + return -1; + } + + int i_iterations = atoi(argv[1]); //how many iterations + int i_outtype = atoi(argv[2]); //how 2 print + int i_threads = atoi(argv[3]); + int i_posix = atoi(argv[4]); + int i__sse = atoi(argv[5]); + bool i_sse = false; + if(i__sse == 1){ + i_sse = true; + } + + //Define size + int x_width = 0; + int y_height = 0; + + switch(i_outtype){ + case 1: + x_width = ASCII_WIDTH; + y_height = ASCII_HEIGHT; + break; + case 2: + x_width = PIXEL_WIDTH; + y_height = PIXEL_HEIGHT; + break; + default: + break; + } + + //create Mandelbrot Obj. + IMandelbrot* mandelbrot; + + if(i_threads <= 1){ + mandelbrot = new CMandelbrotSimple(x_width, y_height, i_iterations, i_threads, i_sse); + } else { + if(i_posix == 1) { + mandelbrot = new CMandelbrotOMP(x_width, y_height, i_iterations, i_threads, i_sse); + } else { + mandelbrot = new CMandelbrotPOSIX(x_width, y_height, i_iterations, i_threads, i_sse); + } + } + + //Calculate stuff + mandelbrot->calculateMandelbrot(); + + //Printstuff + CPainter::print(i_outtype, mandelbrot->getOutArray(), x_width, y_height); + + delete mandelbrot; + + return 0; +} diff --git a/ws2010/gdi3/p5/posix_threads.cpp b/ws2010/gdi3/p5/posix_threads.cpp new file mode 100644 index 00000000..51a6cff7 --- /dev/null +++ b/ws2010/gdi3/p5/posix_threads.cpp @@ -0,0 +1,95 @@ +/* + * posix_threads.cpp + * + * Created on: 10.01.2011 + * Author: mk + */ + +#include // POSIX-threads +#include // time operations (to calculate the runtime) +#include // standard IO operations (to print to console) +#include // general purpose standard library (to generate random numbers) +#define NUM_ELEMENTS 1000000 // number of array-elements to add + +pthread_t* threads; // stores the posix-thread-objects +int* threadNums; // stores the thread-numbers +time_t beginCalc,endCalc; // used to calculate the runtime of the program +unsigned long a[NUM_ELEMENTS],b[NUM_ELEMENTS],c[NUM_ELEMENTS]; // arrays to add (c=a+b) +int numThreads; // number of threads to create + +/* + * fills the arrays with random numbers between 0 and 9 + */ +void fillArrays() +{ + for(unsigned i=0;i1) + { + threads = (pthread_t*)malloc(numThreads*sizeof(pthread_t)); // reserve memory for the threads + threadNums = (int*)malloc(numThreads*sizeof(int)); // reserve memory for the thread-numbers + for (unsigned i=0;i> %eax (5bit zahl) + +movl %eax, %ebx # zahl kopieren +movl $0, %ecx # c = 0 +andl 1000b, %ebx # b = 1 oder 0 +addl %ebx, %ecx # c += b +movl %eax, %ebx # zahl kopieren +and 0100b, %ebx # b = 1 oder 0 +addl %ebx, %ecx # c += b +and 0010b, %ebx # b = 1 oder 0 +addl %ebx, %ecx # c += b +and 0001b, %ebx # b = 1 oder 0 +addl %ebx, %ecx # c += b + +and 0001b , %ecx #counter ungerade? + +shrl $1, %eax #shifte zahl um 1 + +or %ecx, %eax #falls counter ungerade war setze 1 and 1. stelle. \ No newline at end of file diff --git a/ws2010/gdi3/u10/GDI 3 Hausuebung 10.pdf b/ws2010/gdi3/u10/GDI 3 Hausuebung 10.pdf new file mode 100644 index 00000000..4c1aec80 Binary files /dev/null and b/ws2010/gdi3/u10/GDI 3 Hausuebung 10.pdf differ diff --git a/ws2010/gdi3/u10/Uebung-10.pdf b/ws2010/gdi3/u10/Uebung-10.pdf new file mode 100644 index 00000000..5488066d Binary files /dev/null and b/ws2010/gdi3/u10/Uebung-10.pdf differ diff --git a/ws2010/gdi3/u10/solution.odt b/ws2010/gdi3/u10/solution.odt new file mode 100644 index 00000000..00fe0933 Binary files /dev/null and b/ws2010/gdi3/u10/solution.odt differ diff --git a/ws2010/gdi3/u11/Uebung-11.pdf b/ws2010/gdi3/u11/Uebung-11.pdf new file mode 100644 index 00000000..b3ce12ef Binary files /dev/null and b/ws2010/gdi3/u11/Uebung-11.pdf differ diff --git a/ws2010/gdi3/u11/a1.txt b/ws2010/gdi3/u11/a1.txt new file mode 100644 index 00000000..83cf8139 --- /dev/null +++ b/ws2010/gdi3/u11/a1.txt @@ -0,0 +1,39 @@ +FORKS: SEMAPHORE[] = {1,1,1,1,1} // Verfgbare Gabeln +PSTATUS: INTEGER[] = {0,0,0,0,0} // 0 = Denken, 1 = Hungrig, 2=Essend + +philosoph i=[0,3] : PROCESS; // Philosoph 0-3 +BEGIN + + IF PSTATUS[i] == 1 //Hat Hunger - Philosoph muss sich selber auf hungrig setzen + BEGIN + P(FORKS[(i+4) mod 5]) + P(FORKS[i]) + + PSTATUS[i] = 2; //Isst + WHILE(PSTATUS[i] == 2) //Philosoph muss sich selber auf denkend setzen + BEGIN + END + + V(FORKS[(i+4) mod 5]) + V(FORKS[i]) + END + +END + +philosoph i=4 : PROCESS; // Philosoph 4 +BEGIN + + IF PSTATUS[i] == 1 //Hat Hunger - Philosoph muss sich selber auf hungrig setzen + BEGIN + P(FORKS[i]) //Reservierung erfolgt in umgekehrter Reihenfolge! + P(FORKS[(i+4) mod 5]) + + PSTATUS[i] = 2; //Isst + WHILE(PSTATUS[i] == 2) //Philosoph muss sich selber auf denkend setzen + BEGIN + END + + V(FORKS[i]) + V(FORKS[(i+4) mod 5]) + END +END \ No newline at end of file diff --git a/ws2010/gdi3/u11/a1a.jpg b/ws2010/gdi3/u11/a1a.jpg new file mode 100644 index 00000000..ec1de9ed Binary files /dev/null and b/ws2010/gdi3/u11/a1a.jpg differ diff --git a/ws2010/gdi3/u11/a1a.vsd b/ws2010/gdi3/u11/a1a.vsd new file mode 100644 index 00000000..33824761 Binary files /dev/null and b/ws2010/gdi3/u11/a1a.vsd differ diff --git a/ws2010/gdi3/u11/a2.jpg b/ws2010/gdi3/u11/a2.jpg new file mode 100644 index 00000000..3207bed4 Binary files /dev/null and b/ws2010/gdi3/u11/a2.jpg differ diff --git a/ws2010/gdi3/u11/a2.vsd b/ws2010/gdi3/u11/a2.vsd new file mode 100644 index 00000000..61bb10dd Binary files /dev/null and b/ws2010/gdi3/u11/a2.vsd differ diff --git a/ws2010/gdi3/u11/solution.odt b/ws2010/gdi3/u11/solution.odt new file mode 100644 index 00000000..6842487b Binary files /dev/null and b/ws2010/gdi3/u11/solution.odt differ diff --git a/ws2010/ts/Hausuebung/a1/RSA.java b/ws2010/ts/Hausuebung/a1/RSA.java new file mode 100644 index 00000000..c428bb46 --- /dev/null +++ b/ws2010/ts/Hausuebung/a1/RSA.java @@ -0,0 +1,187 @@ +import java.lang.Math; +import java.math.BigInteger; +import java.util.Random; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +public class RSA { + + final static BigInteger m = + new BigInteger("91011121314151617181920212223242526272829",10); + BigInteger p = new BigInteger("0",10); + BigInteger q = new BigInteger("0",10); + BigInteger phi = new BigInteger("0",10); + BigInteger e = new BigInteger("0",10); + BigInteger sha = new BigInteger("0",10); + BigInteger n = new BigInteger("0",10); + BigInteger d = new BigInteger("0",10); + + BigInteger encrypted = new BigInteger("0",10); + BigInteger decrypted = new BigInteger("0",10); + + //Generates a PrimNumber + private BigInteger genPrim(int bitlen){ + BigInteger p = BigInteger.probablePrime(bitlen, new Random()); + if(!p.isProbablePrime(100000)){ + throw new RuntimeException(); + } + return p; + } + + //Generates an E using phi + private void genE(BigInteger phi){ + e = genPrim(256); + + if(!phi.gcd(e).equals(BigInteger.ONE)){ + genE(phi); + } + } + + //Encrypt-Funktion + public void encrypt(){ + q = genPrim(256); //get q + p = genPrim(256); //get p + + if(p.equals(q)){ //ensure p!=q + encrypt(); + } + + phi = p.subtract(BigInteger.ONE).multiply( + q.subtract(BigInteger.ONE)); //phi=(p - 1)(q - 1) + + n = p.multiply(q); //n = p*q + + genE(phi); //get e + + SHA256(); //calculate Hash of m + + encrypted = expModuloN(sha, e, n); // hash^e mod n + } + + //Decrypt Function (you need 2 run encrypt first) + public void decrypt(){ + + d = extEuklid(e, phi); //calculate d + + decrypted = expModuloN(encrypted, d, n); //decrypt + + } + + //extended Euklid-Algorithm + private BigInteger extEuklid(BigInteger a, BigInteger b){ + + //Ancor + if(b.equals(BigInteger.ZERO)){ + return BigInteger.ONE; + } + + //Initialize vars + BigInteger x1 = new BigInteger("0",10); + BigInteger x2 = new BigInteger("1",10); + BigInteger y = new BigInteger("1",10); + BigInteger y1 = new BigInteger("1",10); + BigInteger y2 = new BigInteger("0",10); + BigInteger r = new BigInteger("0",10); + BigInteger q = new BigInteger("0",10); + BigInteger x = new BigInteger("0",10); + + while(b.compareTo(BigInteger.ZERO) == 1){ + q = a.divide(b); + r = a.mod(b); + x = x2.subtract(q.multiply(x1)); + y = y2.subtract(q.multiply(y1)); + a = b; + b = r; + x2 = x1; + x1 = x; + y2 = y1; + y1 = y; + } + + if(x2.compareTo(BigInteger.ZERO) == -1){ + x2 = phi.add(x2); + } + + return x2; //only x2 is needed + + } + + + //Efficient m^e mod n + private BigInteger expModuloN(BigInteger m, BigInteger e, BigInteger n){ + + BigInteger b = m; + BigInteger r = BigInteger.ONE; + + for(int i = 0; i <= e.bitLength(); i++){ + + if(e.testBit(i)){ + r = r.multiply(b).mod(n); + } + + b = b.multiply(b).mod(n); + } + + return r; + } + + //Converts a byte to a HexString + public String BytetoHex(byte b) { + int value = (b & 0x7F) + (b < 0 ? 128 : 0); + + String ret = (value < 16 ? "0" : ""); + ret += Integer.toHexString(value).toUpperCase(); + + return ret; + } + + //Converts SHA-byte-array to HexString + public String SHAtoHex(byte[] d) + { + StringBuffer buf = new StringBuffer(); + + for (int i = 0; i < d.length; i++) { + buf.append(BytetoHex(d[i])); + } + + return buf.toString(); + } + + + //Calculates SHA256 of m + private void SHA256(){ + try { + MessageDigest l = MessageDigest.getInstance("SHA-256"); + l.reset(); + l.update(m.toByteArray()); + sha = new BigInteger(SHAtoHex(l.digest()), 16); + } catch (NoSuchAlgorithmException e) { + throw new RuntimeException(); + } + } + + public static void main(String[] args) { + + RSA r = new RSA(); + + r.encrypt(); //calculate all + r.decrypt(); + + //Print all + System.out.println("\nKey public:"); + System.out.println("\t e: " + r.e); + System.out.println("\t n: " + r.n); + System.out.println("\nKey private:"); + System.out.println("\t d: " + r.d); + System.out.println("\nHashvalue:"); + System.out.println("\t sha: " + r.sha); + System.out.println("\nSignature:"); + System.out.println("\t Enc.: " + r.encrypted); + System.out.println("\nDecrypted:"); + System.out.println("\t Dec.: " + r.decrypted); + System.out.println("\nSHA = Decrypted:"); + System.out.println(r.decrypted.equals(r.sha)); + + } + +} diff --git a/ws2010/ts/Hausuebung/a3.JPG b/ws2010/ts/Hausuebung/a3.JPG new file mode 100644 index 00000000..73d8d1a7 Binary files /dev/null and b/ws2010/ts/Hausuebung/a3.JPG differ diff --git a/ws2010/ts/Hausuebung/a4.JPG b/ws2010/ts/Hausuebung/a4.JPG new file mode 100644 index 00000000..45e02445 Binary files /dev/null and b/ws2010/ts/Hausuebung/a4.JPG differ diff --git a/ws2010/ts/Hausuebung/a5.JPG b/ws2010/ts/Hausuebung/a5.JPG new file mode 100644 index 00000000..7af89642 Binary files /dev/null and b/ws2010/ts/Hausuebung/a5.JPG differ diff --git a/ws2010/ts/Hausuebung/a6/a6.odt b/ws2010/ts/Hausuebung/a6/a6.odt new file mode 100644 index 00000000..31480c6f Binary files /dev/null and b/ws2010/ts/Hausuebung/a6/a6.odt differ diff --git a/ws2010/ts/Hausuebung/hausuebung.pdf b/ws2010/ts/Hausuebung/hausuebung.pdf new file mode 100644 index 00000000..1469a65f Binary files /dev/null and b/ws2010/ts/Hausuebung/hausuebung.pdf differ diff --git a/ws2010/ts/Hausuebung/hu_ulf.odt b/ws2010/ts/Hausuebung/hu_ulf.odt new file mode 100644 index 00000000..f4b56643 Binary files /dev/null and b/ws2010/ts/Hausuebung/hu_ulf.odt differ diff --git a/ws2010/ts/Hausuebung/test.xps b/ws2010/ts/Hausuebung/test.xps new file mode 100644 index 00000000..04709585 Binary files /dev/null and b/ws2010/ts/Hausuebung/test.xps differ diff --git a/ws2010/ts/Klausurergebnisse/DSC00242.JPG b/ws2010/ts/Klausurergebnisse/DSC00242.JPG new file mode 100644 index 00000000..ec6db1d8 Binary files /dev/null and b/ws2010/ts/Klausurergebnisse/DSC00242.JPG differ diff --git a/ws2010/ts/Klausurergebnisse/DSC00243.JPG b/ws2010/ts/Klausurergebnisse/DSC00243.JPG new file mode 100644 index 00000000..6b218e28 Binary files /dev/null and b/ws2010/ts/Klausurergebnisse/DSC00243.JPG differ diff --git a/ws2010/ts/Klausurergebnisse/DSC00244.JPG b/ws2010/ts/Klausurergebnisse/DSC00244.JPG new file mode 100644 index 00000000..dc2dbd3e Binary files /dev/null and b/ws2010/ts/Klausurergebnisse/DSC00244.JPG differ diff --git a/ws2010/ts/Klausurergebnisse/DSC00245.JPG b/ws2010/ts/Klausurergebnisse/DSC00245.JPG new file mode 100644 index 00000000..a425db9d Binary files /dev/null and b/ws2010/ts/Klausurergebnisse/DSC00245.JPG differ diff --git a/ws2010/ts/Klausurvorbereitung/Buchmann - Einfuehrung in die Kryptographie (Springer, 2008).pdf b/ws2010/ts/Klausurvorbereitung/Buchmann - Einfuehrung in die Kryptographie (Springer, 2008).pdf new file mode 100644 index 00000000..ce42feaa Binary files /dev/null and b/ws2010/ts/Klausurvorbereitung/Buchmann - Einfuehrung in die Kryptographie (Springer, 2008).pdf differ diff --git a/ws2010/ts/Klausurvorbereitung/EiTS Zusammenfassung.pdf b/ws2010/ts/Klausurvorbereitung/EiTS Zusammenfassung.pdf new file mode 100644 index 00000000..99a57347 Binary files /dev/null and b/ws2010/ts/Klausurvorbereitung/EiTS Zusammenfassung.pdf differ diff --git a/ws2010/ts/Klausurvorbereitung/Klausurinfo.txt b/ws2010/ts/Klausurvorbereitung/Klausurinfo.txt new file mode 100644 index 00000000..6bdc231d --- /dev/null +++ b/ws2010/ts/Klausurvorbereitung/Klausurinfo.txt @@ -0,0 +1,11 @@ +Klausur Infos: + +Mitteilung vom Assistent in der letzten Vorlesung: + +- 1 Aufgabe: Multiply Choice aus allen Gebieten +- RSA, RSA-Signatur (erweiterter euklidischer Algorithmus), schnelle Exponentation +- El-Gamal (was ist diskreter Algorithmus? usw.) +- Authentifikationsprotokolle (Bsp. Hausbung) +- Exit-Louroll.? (Bell-La Padula) +- zuverlssige Systeme +- letzten beiden Folienstze (Testen, Verifizieren) -> aktuelle bung \ No newline at end of file diff --git a/ws2010/ts/Klausurvorbereitung/reliability_mttf_berechnen.jpg b/ws2010/ts/Klausurvorbereitung/reliability_mttf_berechnen.jpg new file mode 100644 index 00000000..b8aa234b Binary files /dev/null and b/ws2010/ts/Klausurvorbereitung/reliability_mttf_berechnen.jpg differ