wrbitmap.c

开放源码的编译器open watcom 1.6.0版的源代码

    }

    if( info != NULL ) {
        info->is_core = core;
    }

    return( bitmap_handle );

}

void WRGetBitmapInfoHeader( BITMAPINFOHEADER *bmih, BITMAP *bm )
{
    bmih->biSize = sizeof( BITMAPINFOHEADER );
    bmih->biWidth = bm->bmWidth;
    bmih->biHeight = bm->bmHeight;
    bmih->biPlanes = 1;
    bmih->biBitCount = bm->bmPlanes;
    bmih->biCompression = 0;
    bmih->biSizeImage = 0;
    bmih->biXPelsPerMeter = 0;
    bmih->biYPelsPerMeter = 0;
    bmih->biClrUsed = 0;
    bmih->biClrImportant = 0;
}

int WRSetRGBValues( RGBQUAD *argbvals, int upperlimit )
{
    int                 i;
    PALETTEENTRY        *pe;
    int                 num;
    HDC                 hdc;

    if( !argbvals ) {
        return( FALSE );
    }

    pe = (PALETTEENTRY *)MemAlloc( upperlimit*sizeof(PALETTEENTRY) );
    if( pe == NULL ) {
        return( FALSE );
    }

    hdc = GetDC( HWND_DESKTOP );
    num = GetSystemPaletteEntries( hdc, 0, upperlimit, pe );
    ReleaseDC( HWND_DESKTOP, hdc );

    for( i=0; i < min(upperlimit, num); ++i ) {
        argbvals[i].rgbBlue = pe[i].peBlue;
        argbvals[i].rgbGreen = pe[i].peGreen;
        argbvals[i].rgbRed = pe[i].peRed;
        argbvals[i].rgbReserved = 0;
    }

    MemFree( pe );

    return( TRUE );
}

int WRGetBitmapInfo( BITMAPINFO *bmi, BITMAP *bm )
{
    RGBQUAD     *rgb_quad;
    int         ret;

    if( !bmi || !bm ) {
        return( FALSE );
    }

    rgb_quad = MemAlloc( RGBQ_SIZE(bm->bmPlanes) );
    if( rgb_quad == NULL ) {
        return( FALSE );
    }

    WRGetBitmapInfoHeader( &(bmi->bmiHeader), bm );
    ret = WRSetRGBValues( rgb_quad, (1 << (bm->bmPlanes)) );
    if( ret ) {
        memcpy( bmi->bmiColors, rgb_quad, RGBQ_SIZE(bm->bmPlanes) );
    }

    MemFree(rgb_quad);

    return( ret );
}

BITMAPINFO *WRGetDIBitmapInfo( HBITMAP hbitmap )
{
    long        size;
    BITMAPINFO  *bmi;
    BITMAP      bm;

    if( hbitmap == (HBITMAP)NULL ) {
        return( NULL );
    }
    GetObject( hbitmap, sizeof(BITMAP), &bm );
    size = DIB_INFO_SIZE( bm.bmPlanes );
    bmi = (BITMAPINFO *)MemAlloc( size );
    if( bmi != NULL ) {
        if( !WRGetBitmapInfo( bmi, &bm ) ) {
            MemFree( bmi );
            bmi = NULL;
        }
    }

    return( bmi );
}

int WRWriteDataInPiecesData( BITMAPINFO *bmi, BYTE **data, uint_32 *size,
                             HBITMAP hbitmap )
{
    HDC         hdc;
    HDC         memdc;
    int         scanline_count;
    int         one_scanline_size;
    long        chunk_size;
    int         start;
    int         num_lines;
    long        byte_count;

    if( !data || !*data || !size ) {
        return( FALSE );
    }

    hdc = GetDC( (HWND)NULL );
    memdc = CreateCompatibleDC( hdc );
    ReleaseDC( (HWND)NULL, hdc );

    byte_count = bmi->bmiHeader.biSizeImage;
    start = 0;
    num_lines = SCANLINE_SIZE;
    one_scanline_size = BITS_TO_BYTES( bmi->bmiHeader.biWidth *
                                           bmi->bmiHeader.biBitCount, 1 );
    scanline_count = bmi->bmiHeader.biHeight;
    chunk_size = one_scanline_size * num_lines;
    while( chunk_size > MAX_CHUNK ) {
        chunk_size >>= 1;
        num_lines = chunk_size / one_scanline_size;
    }

    while( scanline_count > num_lines ) {
        GetDIBits( memdc, hbitmap, start, num_lines, *data + *size,
                   bmi, DIB_RGB_COLORS );
        *size += chunk_size;
        scanline_count -= num_lines;
        start += num_lines;
        byte_count -= chunk_size;
    }
    GetDIBits( memdc, hbitmap, start, scanline_count, *data + *size,
               bmi, DIB_RGB_COLORS );
    *size += ( scanline_count * one_scanline_size );

    DeleteDC( memdc );

    return(TRUE);
}

int WR_EXPORT WRWriteBitmapToData( HBITMAP hbitmap, BYTE **data,
                                   uint_32 *size )
{
    BITMAPFILEHEADER    bmfh;
    BITMAPINFO          *bmi;
    long                bitmap_size;
    long                number_of_bytes;
    HDC                 hdc;

    if( hbitmap == (HBITMAP)NULL || !data || !size ) {
        return( FALSE );
    }

    bmi = WRGetDIBitmapInfo( hbitmap );
    if( bmi == NULL ) {
        return( FALSE );
    }

    number_of_bytes = BITS_TO_BYTES( bmi->bmiHeader.biBitCount *
                                     bmi->bmiHeader.biWidth,
                                     bmi->bmiHeader.biHeight );

    bitmap_size = DIB_INFO_SIZE( bmi->bmiHeader.biBitCount );

    hdc = GetDC( (HWND)NULL );
    GetDIBits( hdc, hbitmap, 0, bmi->bmiHeader.biHeight, NULL,
               bmi, DIB_RGB_COLORS );
    ReleaseDC( (HWND)NULL, hdc );

    if( bmi->bmiHeader.biSizeImage == 0) {
        bmi->bmiHeader.biSizeImage = number_of_bytes;
    } else {
        number_of_bytes = bmi->bmiHeader.biSizeImage;
    }

    bmfh.bfType = BITMAP_TYPE;
    bmfh.bfSize = sizeof(BITMAPFILEHEADER) + bitmap_size + number_of_bytes;
    bmfh.bfReserved1 = 0;
    bmfh.bfReserved2 = 0;
    bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + bitmap_size;

    // make sure the bitmap can actually be malloc'd!!
    if( bmfh.bfSize > INT_MAX ) {
        MemFree( bmi );
        return( FALSE );
    }

    *data = MemAlloc( bmfh.bfSize );
    if( *data == NULL ) {
        MemFree( bmi );
        return( FALSE );
    }
    *size = 0;

    memcpy( *data + *size, &bmfh, sizeof(BITMAPFILEHEADER) );
    *size += sizeof(BITMAPFILEHEADER);

    memcpy( *data + *size, bmi, bitmap_size );
    *size += bitmap_size;

    if( !WRWriteDataInPiecesData( bmi, data, size, hbitmap ) ) {
        MemFree( bmi );
        return(FALSE);
    }

    MemFree( bmi );

    return( TRUE );
} /* saveBitmapToData */

int WR_EXPORT WRAddBitmapFileHeader( BYTE **data, uint_32 *size )
{
    BITMAPFILEHEADER    *bmfh;
    BITMAPINFO          *bmi;
    BITMAPCOREINFO      *bmci;
    int                 hsize;
    int                 is_core;

    if( !data || !size ) {
        return( FALSE );
    }

    is_core = ( *((DWORD *)(*data)) == sizeof( BITMAPCOREHEADER ) );

    hsize = sizeof(BITMAPFILEHEADER);
    *data = WRMemRealloc( *data, *size + hsize );
    if( !*data ) {
        return( FALSE );
    }
    memmove( *data + hsize, *data, *size );
    memset( *data, 0, hsize );
    *size += hsize;

    bmfh = (BITMAPFILEHEADER *)*data;
    bmfh->bfType = BITMAP_TYPE;
    bmfh->bfSize = *size;
    bmfh->bfOffBits = hsize;

    if( is_core ) {
        bmci = (BITMAPCOREINFO *)( *data + hsize );
        bmfh->bfOffBits += CORE_INFO_SIZE( bmci->bmciHeader.bcBitCount );
    } else {
        bmi  = (BITMAPINFO *)( *data + hsize );
        bmfh->bfOffBits += DIB_INFO_SIZE( bmi->bmiHeader.biBitCount );
    }

    return( TRUE );
}

int WR_EXPORT WRStripBitmapFileHeader( BYTE **data, uint_32 *size )
{
    int         bfhsize;
    if( data && size ) {
        bfhsize = sizeof(BITMAPFILEHEADER);
        memmove( *data, *data + bfhsize, *size - bfhsize );
        *size -= bfhsize;
        return( TRUE );
    }

    return( FALSE );
}

void WR_EXPORT WRForgetBitmapName( void )
{
    if( BitmapName != NULL ) {
        WRMemFree( BitmapName );
        BitmapName = NULL;
    }
}

void WR_EXPORT WRRememberBitmapName( WResID *name )
{
    WRForgetBitmapName();
    BitmapName = WRCopyWResID( name );
}

WResID * WR_EXPORT WRRecallBitmapName( void )
{
    return( WRCopyWResID( BitmapName ) );
}