WinAPI - graphics filters

#include <assert.h>
#include <windows.h>
#include <stdio.h>
#include <exception>

TCHAR NazwaAplikacji[] = TEXT("Przetwarzanie obrazu");
TCHAR NazwaKlasy[] = TEXT("OKNOGLOWNE");

char *Rysunek = 0;
char *Filtrowany = 0;
DWORD RozmiarRysunku = 0;
unsigned char NrFiltru = 0;
double CzasFiltrowania = 0.0;

struct RGB { unsigned char B, G, R; };

inline unsigned int RoundUp4(const unsigned int i)
{
    return (i+3)&(~3);
}

static void AplikujFiltr()
{
    assert(sizeof(RGB) == 3);
    BITMAPFILEHEADER *bfh = reinterpret_cast<BITMAPFILEHEADER*>(Filtrowany);
    BITMAPINFO *bi = reinterpret_cast<BITMAPINFO*>(Filtrowany + sizeof(BITMAPFILEHEADER));
    if ((bi->bmiHeader.biBitCount != 24) && (bi->bmiHeader.biBitCount != 32)) throw std::exception();
    RGB *Raster = reinterpret_cast<RGB*>(Filtrowany + bfh->bfOffBits);
    RGB *Punkt;
    register int Wiersz, Kolumna;
    switch (NrFiltru) {
        case 1:
            for (Wiersz = 0; Wiersz < bi->bmiHeader.biHeight; ++Wiersz) {
                Punkt = Raster + RoundUp4(Wiersz * bi->bmiHeader.biWidth * sizeof(RGB)) / sizeof(RGB);
                for (Kolumna = 0; Kolumna < bi->bmiHeader.biWidth; ++Kolumna) {
                    Punkt->R = 255 - Punkt->R;
                    Punkt->G = 255 - Punkt->G;
                    Punkt->B = 255 - Punkt->B;
                    ++Punkt;
                }
            }
            break;
        case 2:
            Sleep(3);
            break;
        case 3:
            Sleep(5);
            break;
        case 4:
            Sleep(7);
            break;
        case 5:
            Sleep(9);
            break;
        case 6:
            Sleep(11);
            break;
    }
}

static void KopiujFiltrowany()
{
    if (Filtrowany == 0) Filtrowany = new char [RozmiarRysunku];
    memcpy(Filtrowany, Rysunek, RozmiarRysunku);
}

static void Tworz(const HWND Okno)
{
    register const HANDLE Plik = CreateFile(TEXT("Obraz.bmp"), GENERIC_READ, FILE_SHARE_READ,
        NULL, OPEN_EXISTING, 0, NULL);
    if (Plik == INVALID_HANDLE_VALUE) {
        MessageBox(Okno, TEXT("Błąd w trakcie otwierania pliku Obraz.bmp"),
            NazwaAplikacji, MB_ICONEXCLAMATION | MB_OK);
        return;
    }
    RozmiarRysunku = GetFileSize(Plik, NULL);
    Rysunek = new char [RozmiarRysunku];
    DWORD Odczytano;
    ReadFile(Plik, Rysunek, RozmiarRysunku, &Odczytano, NULL);
    CloseHandle(Plik);
    KopiujFiltrowany();
}

static void Rysuj(const HWND Okno)
{
    RECT Rozmiar;
    TCHAR Tekst[64];
    PAINTSTRUCT PS;
    unsigned int dl;
    GetClientRect(Okno, &Rozmiar);
    const HDC DC = BeginPaint(Okno, &PS);
    if (Rysunek != 0) {
        BITMAPFILEHEADER *bfh = reinterpret_cast<BITMAPFILEHEADER*>(Filtrowany);
        BITMAPINFO *bi = reinterpret_cast<BITMAPINFO*>(Filtrowany + sizeof(BITMAPFILEHEADER));
        SetStretchBltMode(DC, HALFTONE);
        StretchDIBits(DC, 0, 0, Rozmiar.right, Rozmiar.bottom, 0, 0, bi->bmiHeader.biWidth, bi->bmiHeader.biHeight,
            static_cast<void*>(Filtrowany + bfh->bfOffBits), bi, DIB_RGB_COLORS, SRCCOPY);
        dl = swprintf(Tekst, TEXT("Czas filtrowania: %.2lf ms"), CzasFiltrowania);
        TextOut(DC, 5, 5, Tekst, dl);
    }
    EndPaint(Okno, &PS);
}

static void Znak(const HWND Okno, const TCHAR Znak)
{
    if (Znak >= TEXT('0') && Znak <= TEXT('9')) {
        SYSTEMTIME S1, S2;
        NrFiltru = Znak - TEXT('0');
        SetWindowText(Okno, TEXT("TRWA FILTROWANIE..."));
        KopiujFiltrowany();
        GetSystemTime(&S1);
        if (NrFiltru > 0 && NrFiltru <= 9)
            for (unsigned int i = 0; i < 500; ++i) AplikujFiltr();
        GetSystemTime(&S2);
        CzasFiltrowania = 3600.0 * (S2.wHour - S1.wHour) + 60.0 * (S2.wMinute - S1.wMinute)
            + (S2.wSecond - S1.wSecond) + 0.001 * (S2.wMilliseconds - S1.wMilliseconds);
        CzasFiltrowania *= 2.0;
        InvalidateRect(Okno, NULL, FALSE);
        SetWindowText(Okno, NazwaAplikacji);
        UpdateWindow(Okno);
    }
}

static LRESULT CALLBACK FunkcjaOkienkowa(HWND Okno, UINT Komunikat, WPARAM wParam, LPARAM lParam)
{
    switch (Komunikat) {
        case WM_CREATE:
            Tworz(Okno);
            break;
        case WM_CHAR:
            Znak(Okno, static_cast<TCHAR>(wParam));
            break;
        case WM_PAINT:
            Rysuj(Okno);
            break;
        case WM_DESTROY:
            delete [] Rysunek;
            delete [] Filtrowany;
            PostQuitMessage(0);
            break;
        default:
            return DefWindowProc(Okno, Komunikat, wParam, lParam);
    }
    return 0;
}

static bool RejestrujKlasy()
{
    WNDCLASSEX wc;
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.cbClsExtra = wc.cbWndExtra = 0;
    wc.hbrBackground = (HBRUSH) (1 + COLOR_WINDOW);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    wc.hInstance = GetModuleHandle(NULL);
    wc.lpfnWndProc = &FunkcjaOkienkowa;
    wc.lpszClassName = NazwaKlasy;
    wc.lpszMenuName = NULL;
    wc.style = CS_HREDRAW | CS_VREDRAW;
    return (RegisterClassEx(&wc) != 0);
}

static void WyrejestrujKlasy()
{
    UnregisterClass(NazwaKlasy, GetModuleHandle(NULL));
}

int WINAPI WinMain(HINSTANCE Instancja, HINSTANCE Poprzednia, LPSTR Parametry, int Widocznosc)
{
    // Zarejestruj klasę. Protestuj, jeżeli wystąpił błąd.
    if (!RejestrujKlasy()) {
        MessageBox(NULL, TEXT("Nie udało się zarejestrować klasy okna!"),
            NazwaAplikacji, MB_ICONSTOP | MB_OK);
        return 1;
    }
    // Stwórz główne okno. Również protestuj, jeżeli wystąpił błąd.
    HWND GlowneOkno = CreateWindowEx(WS_EX_APPWINDOW | WS_EX_CLIENTEDGE,
        NazwaKlasy, NazwaAplikacji, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        NULL, NULL, Instancja, NULL);
    if (GlowneOkno == NULL) {
        MessageBox(NULL, TEXT("Nie udało się stworzyć głównego okna!"),
            NazwaAplikacji, MB_ICONSTOP | MB_OK);
        return 2;
    }
    // Wyświetl i uaktualnij nowo stworzone okno.
    ShowWindow(GlowneOkno, Widocznosc);
    UpdateWindow(GlowneOkno);
    // Główna pętla komunikatów wątku.
    MSG Komunikat;
    while (GetMessage(&Komunikat, NULL, 0, 0) > 0) {
        TranslateMessage(&Komunikat);
        DispatchMessage(&Komunikat);
    }
    // Zwolnij pamięć klas i zakończ proces.
    WyrejestrujKlasy();
    return static_cast<int>(Komunikat.wParam);
}