ydb/contrib/python/Pillow/py3/libImaging/Dib.c

/*
 * The Python Imaging Library
 * $Id$
 *
 * imaging display object for Windows
 *
 * history:
 * 1996-05-12 fl  Created
 * 1996-05-17 fl  Up and running
 * 1996-05-21 fl  Added palette stuff
 * 1996-05-26 fl  Added query palette and mode inquery
 * 1997-09-21 fl  Added draw primitive
 * 1998-01-20 fl  Use StretchDIBits instead of StretchBlt
 * 1998-12-30 fl  Plugged a resource leak in DeleteDIB (from Roger Burnham)
 *
 * Copyright (c) Secret Labs AB 1997-2001.
 * Copyright (c) Fredrik Lundh 1996.
 *
 * See the README file for information on usage and redistribution.
 */

#include "Imaging.h"

#ifdef _WIN32

#include "ImDib.h"

char *
ImagingGetModeDIB(int size_out[2]) {
    /* Get device characteristics */

    HDC dc;
    char *mode;

    dc = CreateCompatibleDC(NULL);

    mode = "P";
    if (!(GetDeviceCaps(dc, RASTERCAPS) & RC_PALETTE)) {
        mode = "RGB";
        if (GetDeviceCaps(dc, BITSPIXEL) == 1) {
            mode = "1";
        }
    }

    if (size_out) {
        size_out[0] = GetDeviceCaps(dc, HORZRES);
        size_out[1] = GetDeviceCaps(dc, VERTRES);
    }

    DeleteDC(dc);

    return mode;
}

ImagingDIB
ImagingNewDIB(const char *mode, int xsize, int ysize) {
    /* Create a Windows bitmap */

    ImagingDIB dib;
    RGBQUAD *palette;
    int i;

    /* Check mode */
    if (strcmp(mode, "1") != 0 && strcmp(mode, "L") != 0 && strcmp(mode, "RGB") != 0) {
        return (ImagingDIB)ImagingError_ModeError();
    }

    /* Create DIB context and info header */
    /* malloc check ok, small constant allocation */
    dib = (ImagingDIB)malloc(sizeof(*dib));
    if (!dib) {
        return (ImagingDIB)ImagingError_MemoryError();
    }
    /* malloc check ok, small constant allocation */
    dib->info = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
    if (!dib->info) {
        free(dib);
        return (ImagingDIB)ImagingError_MemoryError();
    }

    memset(dib->info, 0, sizeof(BITMAPINFOHEADER));
    dib->info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    dib->info->bmiHeader.biWidth = xsize;
    dib->info->bmiHeader.biHeight = ysize;
    dib->info->bmiHeader.biPlanes = 1;
    dib->info->bmiHeader.biBitCount = strlen(mode) * 8;
    dib->info->bmiHeader.biCompression = BI_RGB;

    /* Create DIB */
    dib->dc = CreateCompatibleDC(NULL);
    if (!dib->dc) {
        free(dib->info);
        free(dib);
        return (ImagingDIB)ImagingError_MemoryError();
    }

    dib->bitmap =
        CreateDIBSection(dib->dc, dib->info, DIB_RGB_COLORS, &dib->bits, NULL, 0);
    if (!dib->bitmap) {
        free(dib->info);
        free(dib);
        return (ImagingDIB)ImagingError_MemoryError();
    }

    strcpy(dib->mode, mode);
    dib->xsize = xsize;
    dib->ysize = ysize;

    dib->pixelsize = strlen(mode);
    dib->linesize = (xsize * dib->pixelsize + 3) & -4;

    if (dib->pixelsize == 1) {
        dib->pack = dib->unpack = (ImagingShuffler)memcpy;
    } else {
        dib->pack = ImagingPackBGR;
        dib->unpack = ImagingPackBGR;
    }

    /* Bind the DIB to the device context */
    dib->old_bitmap = SelectObject(dib->dc, dib->bitmap);

    palette = dib->info->bmiColors;

    /* Bind a palette to it as well (only required for 8-bit DIBs) */
    if (dib->pixelsize == 1) {
        for (i = 0; i < 256; i++) {
            palette[i].rgbRed = palette[i].rgbGreen = palette[i].rgbBlue = i;
            palette[i].rgbReserved = 0;
        }
        SetDIBColorTable(dib->dc, 0, 256, palette);
    }

    /* Create an associated palette (for 8-bit displays only) */
    if (strcmp(ImagingGetModeDIB(NULL), "P") == 0) {
        char palbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
        LPLOGPALETTE pal = (LPLOGPALETTE)palbuf;
        int i, r, g, b;

        /* Load system palette */
        pal->palVersion = 0x300;
        pal->palNumEntries = 256;
        GetSystemPaletteEntries(dib->dc, 0, 256, pal->palPalEntry);

        if (strcmp(mode, "L") == 0) {
            /* Grayscale DIB.  Fill all 236 slots with a grayscale ramp
             * (this is usually overkill on Windows since VGA only offers
             * 6 bits grayscale resolution).  Ignore the slots already
             * allocated by Windows */

            i = 10;
            for (r = 0; r < 236; r++) {
                pal->palPalEntry[i].peRed = pal->palPalEntry[i].peGreen =
                    pal->palPalEntry[i].peBlue = i;
                i++;
            }

            dib->palette = CreatePalette(pal);

        } else if (strcmp(mode, "RGB") == 0) {
#ifdef CUBE216

            /* Colour DIB.  Create a 6x6x6 colour cube (216 entries) and
             * add 20 extra graylevels for best result with grayscale
             * images. */

            i = 10;
            for (r = 0; r < 256; r += 51) {
                for (g = 0; g < 256; g += 51) {
                    for (b = 0; b < 256; b += 51) {
                        pal->palPalEntry[i].peRed = r;
                        pal->palPalEntry[i].peGreen = g;
                        pal->palPalEntry[i].peBlue = b;
                        i++;
                    }
                }
            }
            for (r = 1; r < 22 - 1; r++) {
                /* Black and white are already provided by the cube. */
                pal->palPalEntry[i].peRed = pal->palPalEntry[i].peGreen =
                    pal->palPalEntry[i].peBlue = r * 255 / (22 - 1);
                i++;
            }

#else

            /* Colour DIB.  Alternate palette. */

            i = 10;
            for (r = 0; r < 256; r += 37) {
                for (g = 0; g < 256; g += 32) {
                    for (b = 0; b < 256; b += 64) {
                        pal->palPalEntry[i].peRed = r;
                        pal->palPalEntry[i].peGreen = g;
                        pal->palPalEntry[i].peBlue = b;
                        i++;
                    }
                }
            }

#endif

            dib->palette = CreatePalette(pal);
        }
    }

    return dib;
}

void
ImagingPasteDIB(ImagingDIB dib, Imaging im, int xy[4]) {
    /* Paste image data into a bitmap */

    /* FIXME: check size! */

    int y;
    for (y = 0; y < im->ysize; y++) {
        dib->pack(
            dib->bits + dib->linesize * (dib->ysize - (xy[1] + y) - 1) +
                xy[0] * dib->pixelsize,
            im->image[y],
            im->xsize);
    }
}

void
ImagingExposeDIB(ImagingDIB dib, void *dc) {
    /* Copy bitmap to display */

    if (dib->palette != 0) {
        SelectPalette((HDC)dc, dib->palette, FALSE);
    }
    BitBlt((HDC)dc, 0, 0, dib->xsize, dib->ysize, dib->dc, 0, 0, SRCCOPY);
}

void
ImagingDrawDIB(ImagingDIB dib, void *dc, int dst[4], int src[4]) {
    /* Copy bitmap to printer/display */

    if (GetDeviceCaps((HDC)dc, RASTERCAPS) & RC_STRETCHDIB) {
        /* stretchdib (printers) */
        StretchDIBits(
            (HDC)dc,
            dst[0],
            dst[1],
            dst[2] - dst[0],
            dst[3] - dst[1],
            src[0],
            src[1],
            src[2] - src[0],
            src[3] - src[1],
            dib->bits,
            dib->info,
            DIB_RGB_COLORS,
            SRCCOPY);
    } else {
        /* stretchblt (displays) */
        if (dib->palette != 0) {
            SelectPalette((HDC)dc, dib->palette, FALSE);
        }
        StretchBlt(
            (HDC)dc,
            dst[0],
            dst[1],
            dst[2] - dst[0],
            dst[3] - dst[1],
            dib->dc,
            src[0],
            src[1],
            src[2] - src[0],
            src[3] - src[1],
            SRCCOPY);
    }
}

int
ImagingQueryPaletteDIB(ImagingDIB dib, void *dc) {
    /* Install bitmap palette */

    int n;

    if (dib->palette != 0) {
        /* Realize associated palette */
        HPALETTE now = SelectPalette((HDC)dc, dib->palette, FALSE);
        n = RealizePalette((HDC)dc);

        /* Restore palette */
        SelectPalette((HDC)dc, now, FALSE);

    } else {
        n = 0;
    }

    return n; /* number of colours that was changed */
}

void
ImagingDeleteDIB(ImagingDIB dib) {
    /* Clean up */

    if (dib->palette) {
        DeleteObject(dib->palette);
    }
    if (dib->bitmap) {
        SelectObject(dib->dc, dib->old_bitmap);
        DeleteObject(dib->bitmap);
    }
    if (dib->dc) {
        DeleteDC(dib->dc);
    }
    free(dib->info);
}

#endif /* _WIN32 */