We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

Complete test case

sdl_undefined_memcpy.c (text/plain), 5.66 KB, created by Petr Pisar on 2011-02-17 08:55:29 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Petr Pisar

Created: 2011-02-17 08:55:29 UTC

Size: 5.66 KB

patch

obsolete

>/* This test checks whether SDL_BlitSurface() works properly on systems with
> * memcp() that does not deal with overlapping areas.
> * Check exit code to get status of the test.
> * All magic numbers have been selected by manual tunning for Intel(R)
> * Core(TM)2 Quad CPU Q9400 processor. These values provide highest
> * possibility to reproduce the bug on that system. */
>
>#include <SDL.h>
>#include <stdlib.h>
>#include <stdio.h>
>
>#define BPP 8
>
>void error(const char *message) {
>    puts(message);
>    SDL_Quit();
>    exit(EXIT_FAILURE);
>}
>
>
>int linearpattern(uint8_t *memory, size_t length, int write) {
>    uint8_t value = 0;
>    int index;
>
>    if (!memory) return -1;
>
>    for (index = 0; index < length; index++) {
>        value++;
>        if (write)
>            memory[index] = value;
>        else
>            if (value != memory[index]) {
>                printf("[%d]=%" PRIu8 ", expected=%" PRIu8 "\n",
>                        index, memory[index], value);
>                return -2;
>            }
>    }
>
>    return 0;
>}
>
>
>int testmemcpy(void) {
>/*#define SIZE (3328)*/
>#define SIZE (400)
>    uint8_t memory[2*SIZE];
>    size_t source = 200;
>    /* 167 not affected, 168 affected sometimes with SIZE 3328*/
>    size_t destination = 0;
>
>    puts("Checking if memcpy(3) can copy overlapping areas");
>    /* Init memory */
>    memset(memory, 0, sizeof(memory));
>
>    /* Fill test pattern */
>    if (linearpattern(memory + source, SIZE, 1))
>        error("Could not fill pattern");
>
>    /* Perform overlapping copy */
>    memcpy(memory + destination, memory + source, SIZE * sizeof(*memory));
>
>    /* Compare results */
>    if (linearpattern(memory + destination, SIZE, 0))
>        puts(
>        "No, memcpy(3) cannot handle overlaping areas.\n"
>        "\n"
>        "Following SDL tests should pass only on fixed SDL.\n");
>    else
>        puts(
>        "Maybe, memcpy(3) test suceeded, but the test is not safe.\n"
>        "It passes sometimes on my machine even if it shouldn't.\n"
>        "Current memmory mapping plays a role probably.\n"
>        "\n"
>        "Following SDLs test will pass regardless SDL is fixed or isn't.\n");
>
>    return 0;
>#undef SIZE
>}
>
>
>int pattern(SDL_Surface *surface, SDL_Rect *rectangle, int write) {
>    Uint8 *pixmap;
>    Uint8 value = 0;
>    int h, w, index;
>
>    if (!surface || !rectangle) return -1;
>
>    pixmap = (Uint8 *)surface->pixels;
>    if (!pixmap) return -1;
>
>    if (rectangle->x < 0 || rectangle->x >= surface->w ||
>            rectangle->x + rectangle->w > surface->w ||
>            rectangle->y < 0 || rectangle->y >= surface->h ||
>            rectangle->y + rectangle->h > surface->h) {
>        puts("Rectangle does not fit into surface, "
>                "off-surface pixels cannot be accessed.");
>        return -1;
>    }
>
>    for (h = rectangle->y; h < rectangle->y + rectangle->h; h++) {
>        for (w = rectangle->x; w < rectangle->x + rectangle->w; w++) {
>            value++;
>            index = h * surface->w + w;
>            if (write)
>                pixmap[index] = value;
>            else
>                if (value != pixmap[index]) {
>                    printf("Pixel does not match pattern: "
>                            "[%d,%d]=%u, expected=%u\n",
>                            w, h, pixmap[index], value);
>                    return -2;
>                }
>        }
>    }
>    return 0;
>}
>
>
>int test(SDL_Surface *surface, SDL_Rect *source, SDL_Rect *destination) {
>    if (!surface || !destination || !source)
>        return -1;
>
>    printf("\nTesting: %ux%u+%d+%d -> %ux%u+%d+%d\n",
>            source->w, source->h, source->x, source->y,
>            destination->w, destination->h, destination->x, destination->y);
>
>    /* Fill test pattern */
>    if (SDL_LockSurface(surface))
>        error("Could not lock surface");
>    memset(surface->pixels, 0, surface->w * surface->h);
>    if (pattern(surface, source, 1))
>        error("Could not fill pattern");
>    SDL_UnlockSurface(surface);
>
>    /* Perform overlapping copy */
>    if (SDL_BlitSurface(surface, source, surface, destination))
>        error("Blitting failed");
>
>    /* Compare results */
>    switch (pattern(surface, destination, 0)) {
>        case -2:
>            error("Destination rectangle does not match pattern");
>        case 0:
>            puts("Destination rectangle matches pattern");
>            break;
>        default:
>            error("Unknown error occured. Test could not been proceeded.");
>    }
>
>    return 0;
>}
>
>
>int main(int argc, char **argv) {
>    SDL_Surface *surface;
>#define SIZE 270
>    SDL_Rect source = { 0, 0, SIZE, SIZE };
>    SDL_Rect destination = { 0, 0, SIZE, SIZE };
>#undef SIZE
>
>    /* Check memcpy(3) implementation. Informative only. */
>    testmemcpy();
>
>    /* Init SDL */
>    if (SDL_Init(SDL_INIT_VIDEO))
>        error("SDL_Init() failed");
>
>    surface = SDL_SetVideoMode(640, 480, BPP, SDL_SWSURFACE);
>    if (!surface)
>        error("SDL_SetVideoMode() failed");
>
>    if (surface->format->BitsPerPixel != BPP)
>        error("Surface has unexpected pixel format");
>
>    /* Perform a tests */
>
>#define OFFSET 200
>    /* Horizontal forward overlap */
>    source.x = 0; source.y = 0;
>    destination.x = OFFSET; destination.y = 0;
>    test(surface, &source, &destination);
>
>    /* Horizontal backward overlap */
>    source.x = OFFSET; source.y = 0;
>    destination.x = 0; destination.y = 0;
>    test(surface, &source, &destination);
>
>    /* Vertical forward overlap */
>    source.x = 0; source.y = 0;
>    destination.x = 0; destination.y = OFFSET;
>    test(surface, &source, &destination);
>
>    /* Vertical backward overlap */
>    source.x = 0; source.y = OFFSET;
>    destination.x = 0; destination.y = 0;
>    test(surface, &source, &destination);
>#undef OFFSET
>
>
>    /* Clean up */
>    SDL_Quit();
>    return EXIT_SUCCESS;
>}
>

Actions: View

Attachments on bug 1090: 573 | 574 | 577 | 579

We are currently migrating Bugzilla to GitHub issues.Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.

We are currently migrating Bugzilla to GitHub issues.
Any changes made to the bug tracker now will be lost, so please do not post new bugs or make changes to them.
When we're done, all bug URLs will redirect to their equivalent location on the new bug tracker.