bitmap.c

ARM9-2410教学实验系统下Linux下minigui程序

    SetRect (&dstOutput, dx, dy, dx + sw, dy + sh);
    NormalizeRect (&dstOutput);

    if (!dc_IsMemDC (psdc) && !dc_IsMemDC (pddc))
        GetBoundRect (&pddc->rc_output, &srcOutput, &dstOutput);
    else
        pddc->rc_output = dstOutput;

    ENTER_DRAWING (pddc);
    if (dc_IsMemDC (pddc) && !dc_IsMemDC (psdc)) ShowCursorForGDI (FALSE, &srcOutput);

    if (pddc->surface == psdc->surface && dy > sy)
        cliprect = pddc->ecrgn.tail;
    else
        cliprect = pddc->ecrgn.head;
    while (cliprect) {
        if (IntersectRect (&eff_rc, &pddc->rc_output, &cliprect->rc)) {
            SET_GAL_CLIPRECT (pddc, eff_rc);

            src.x = sx; src.y = sy; src.w = sw; src.h = sh;
            dst.x = dx; dst.y = dy; dst.w = sw; dst.h = sh;
            GAL_BlitSurface (psdc->surface, &src, pddc->surface, &dst);
        }

        if (pddc->surface == psdc->surface && dy > sy)
            cliprect = cliprect->prev;
        else
            cliprect = cliprect->next;
    }

    if (dc_IsMemDC (pddc) && !dc_IsMemDC (psdc)) ShowCursorForGDI (TRUE, &srcOutput);
    LEAVE_DRAWING (pddc);

    UNLOCK_GCRINFO (pddc);
}

void GUIAPI StretchBlt (HDC hsdc, int sx, int sy, int sw, int sh,
                       HDC hddc, int dx, int dy, int dw, int dh, DWORD dwRop)
{
    PDC psdc, pddc;
    PCLIPRECT cliprect;
    RECT srcOutput, dstOutput;
    GAL_Rect src, dst;
    RECT eff_rc;

    psdc = dc_HDC2PDC (hsdc);
    if (!(pddc = check_ecrgn (hddc)))
        return;

    if (sw <= 0 || sh <= 0) {
        sw = RECTW (psdc->DevRC);
        sh = RECTH (psdc->DevRC);
    }
    if (dw <= 0 || dh <= 0) {
        dw = RECTW (pddc->DevRC);
        dh = RECTH (pddc->DevRC);
    }
    // Transfer logical to device to screen here.
    sw += sx; sh += sy;
    coor_LP2SP(psdc, &sx, &sy);
    coor_LP2SP(psdc, &sw, &sh);
    SetRect (&srcOutput, sx, sy, sw, sh);
    NormalizeRect (&srcOutput);
    sw = RECTW (srcOutput); sh = RECTH (srcOutput);

    dw += dx; dh += dy;
    coor_LP2SP (pddc, &dx, &dy);
    coor_LP2SP (pddc, &dw, &dh);
    SetRect (&dstOutput, dx, dy, dw, dh);
    NormalizeRect (&dstOutput);
    dw = RECTW (dstOutput); dh = RECTH (dstOutput);

    if (!dc_IsMemDC (psdc) && !dc_IsMemDC (pddc))
        GetBoundRect (&pddc->rc_output, &srcOutput, &dstOutput);
    else
        pddc->rc_output = dstOutput;

    ENTER_DRAWING (pddc);
    if (!dc_IsMemDC (psdc) && dc_IsMemDC (pddc)) ShowCursorForGDI (FALSE, &srcOutput);

    if (pddc->surface == psdc->surface && dy > sy)
        cliprect = pddc->ecrgn.tail;
    else
        cliprect = pddc->ecrgn.head;
    while(cliprect) {
        if (IntersectRect (&eff_rc, &pddc->rc_output, &cliprect->rc)) {
            SET_GAL_CLIPRECT (pddc, eff_rc);

            src.x = sx; src.y = sy; src.w = sw; src.h = sh;
            dst.x = dx; dst.y = dy; dst.w = dw; dst.h = dh;
            GAL_SoftStretch (psdc->surface, &src, pddc->surface, &dst);
        }

        if (pddc->surface == psdc->surface && dy > sy)
            cliprect = cliprect->prev;
        else
            cliprect = cliprect->next;
    }
    if (!dc_IsMemDC (psdc) && dc_IsMemDC (pddc)) ShowCursorForGDI (TRUE, &srcOutput);
    LEAVE_DRAWING (pddc);

    UNLOCK_GCRINFO (pddc);
}

/* 
 * This function performs a fast box scaling.
 * This is a DDA-based algorithm; Iteration over target bitmap.
 *
 * This function comes from SVGALib, Copyright 1993 Harm Hanemaayer
 */

/* We use the 32-bit to 64-bit multiply and 64-bit to 32-bit divide of the
 * 386 (which gcc doesn't know well enough) to efficiently perform integer
 * scaling without having to worry about overflows.
 */

#if defined(__GNUC__) && defined(i386)

static inline int muldiv64(int m1, int m2, int d)
{
    /* int32 * int32 -> int64 / int32 -> int32 */
    int result;
    int dummy;
    __asm__ __volatile__ (
               "imull %%edx\n\t"
               "idivl %4\n\t"
  :               "=a"(result), "=d"(dummy)        /* out */
  :               "0"(m1), "1"(m2), "g"(d)                /* in */
               /***rjr***:               "ax", "dx"***/        /* mod */
        );
    return result;
}

#else

static inline int muldiv64 (int m1, int m2, int d)
{
    long long int mul = (long long int) m1 * m2;

    return (int) (mul / d);
}

#endif

BOOL ScaleBitmap (BITMAP *dst, const BITMAP *src)
{
    BYTE *dp1 = src->bmBits;
    BYTE *dp2 = dst->bmBits;
    int xfactor;
    int yfactor;

    if (dst->bmWidth == 0 || dst->bmHeight == 0)
        return TRUE;

    if (dst->bmBytesPerPixel != src->bmBytesPerPixel)
        return FALSE;

    xfactor = muldiv64 (src->bmWidth, 65536, dst->bmWidth);         /* scaled by 65536 */
    yfactor = muldiv64 (src->bmHeight, 65536, dst->bmHeight);       /* scaled by 65536 */

    switch (dst->bmBytesPerPixel) {
    case 1:
        {
            int y, sy;
            sy = 0;
            for (y = 0; y < dst->bmHeight;) {
                int sx = 0;
                BYTE *dp2old = dp2;
                int x;
                x = 0;
#if 0 // defined(__GNUC__) && defined(i386)
                while (x < dst->bmWidth - 8) {
                    /* This saves just a couple of cycles per */
                    /* pixel on a 486, but I couldn't resist. */
                    __asm__ __volatile__("movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 1 (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 2 (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 3 (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 4 (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 5 (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 6 (%1, %2)\n\t"
                                         "movl %4, %%eax\n\t"
                                         "shrl $16, %%eax\n\t"
                                         "addl %5, %4\n\t"
                                         "movb (%3, %%eax), %%al\n\t"
                                         "movb %%al, 7 (%1, %2)\n\t"
                                         :        /* output */
                                         :        /* input */
                                         "ax"(0), "r"(dp2), "r"(x), "r"(dp1),
                                         "r"(sx), "r"(xfactor)
                                         :"ax", "4"
                    );
                    *(dp2 + x) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 1) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 2) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 3) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 4) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 5) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 6) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    *(dp2 + x + 7) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    x += 8;
                }
#endif
                while (x < dst->bmWidth) {
                    *(dp2 + x) = *(dp1 + (sx >> 16));
                    sx += xfactor;
                    x++;
                }
                dp2 += dst->bmPitch;
                y++;
                while (y < dst->bmHeight) {
                    int l;
                    int syint = sy >> 16;
                    sy += yfactor;
                    if ((sy >> 16) != syint)
                        break;
                    /* Copy identical lines. */
                    l = dp2 - dp2old;
                    memcpy(dp2, dp2old, l);
                    dp2old = dp2;
                    dp2 += l;
                    y++;
                }
                dp1 = src->bmBits + (sy >> 16) * src->bmPitch;
            }
        }
    break;
    case 2:
        {
            int y, sy;
            sy = 0;
            for (y = 0; y < dst->bmHeight;) {
                int sx = 0;
                BYTE *dp2old = dp2;
                int x;
                x = 0;
                /* This can be greatly optimized with loop */
                /* unrolling; omitted to save space. */
                while (x < dst->bmWidth) {
                    *(unsigned short *) (dp2 + x * 2) =
                        *(unsigned short *) (dp1 + (sx >> 16) * 2);
                    sx += xfactor;
                    x++;
                }
                dp2 += dst->bmPitch;
                y++;
                while (y < dst->bmHeight) {
                    int l;
                    int syint = sy >> 16;
                    sy += yfactor;
                    if ((sy >> 16) != syint)
                        break;
                    /* Copy identical lines. */
                    l = dp2 - dp2old;
                    memcpy(dp2, dp2old, l);
                    dp2old = dp2;
                    dp2 += l;
                    y++;
                }
                dp1 = src->bmBits + (sy >> 16) * src->bmPitch;
            }
        }
    break;
    case 3:
        {
            int y, sy;
            sy = 0;
            for (y = 0; y < dst->bmHeight;) {
                int sx = 0;
                BYTE *dp2old = dp2;
                int x;
                x = 0;
                /* This can be greatly optimized with loop */
                /* unrolling; omitted to save space. */
                while (x < dst->bmWidth) {
                    *(unsigned short *) (dp2 + x * 3) =
                        *(unsigned short *) (dp1 + (sx >> 16) * 3);
                    *(unsigned char *) (dp2 + x * 3 + 2) =
                        *(unsigned char *) (dp1 + (sx >> 16) * 3 + 2);
                    sx += xfactor;
                    x++;
                }
                dp2 += dst->bmPitch;
                y++;
                while (y < dst->bmHeight) {
                    int l;
                    int syint = sy >> 16;
                    sy += yfactor;
                    if ((sy >> 16) != syint)
                        break;
                    /* Copy identical lines. */
                    l = dp2 - dp2old;
                    memcpy(dp2, dp2old, l);
                    dp2old = dp2;
                    dp2 += l;
                    y++;
                }
                dp1 = src->bmBits + (sy >> 16) * src->bmPitch;
            }
        }
    break;
    case 4:
        {
            int y, sy;
            sy = 0;
            for (y = 0; y < dst->bmHeight;) {
                int sx = 0;
                BYTE *dp2old = dp2;