Refactored bitmap API.

diff --git a/include/freerdp/graphics.h b/include/freerdp/graphics.h
index edf3499..14c2774 100644 (file)
--- a/include/freerdp/graphics.h
+++ b/include/freerdp/graphics.h
@@ -74,17 +74,12 @@ struct rdp_bitmap
 };
 
 FREERDP_API rdpBitmap* Bitmap_Alloc(rdpContext* context);
-FREERDP_API BOOL Bitmap_New(rdpContext* context, rdpBitmap* bitmap);
-FREERDP_API void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap);
-FREERDP_API BOOL Bitmap_Register(rdpContext* context, rdpBitmap* bitmap);
-FREERDP_API BOOL Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
-                                   BYTE* data, int width, int height, int bpp, int length, BOOL compressed);
-FREERDP_API void Bitmap_SetRectangle(rdpContext* context, rdpBitmap* bitmap,
-                                     UINT16 left, UINT16 top, UINT16 right, UINT16 bottom);
-FREERDP_API void Bitmap_SetDimensions(rdpContext* context, rdpBitmap* bitmap,
-                                      UINT16 width, UINT16 height);
-FREERDP_API BOOL Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap,
-                                   BOOL primary);
+FREERDP_API BOOL Bitmap_SetRectangle(rdpBitmap* bitmap,
+                                     UINT16 left,
+                                     UINT16 top, UINT16 right, UINT16 bottom);
+FREERDP_API BOOL Bitmap_SetDimensions(rdpBitmap* bitmap,
+                                      UINT16 width,
+                                      UINT16 height);
 
 /* Pointer Class */
 

diff --git a/libfreerdp/cache/bitmap.c b/libfreerdp/cache/bitmap.c
index ee2a452..e5c627b 100644 (file)
--- a/libfreerdp/cache/bitmap.c
+++ b/libfreerdp/cache/bitmap.c
@@ -35,11 +35,13 @@
 
 #define TAG FREERDP_TAG("cache.bitmap")
 
-static rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index);
-static void bitmap_cache_put(rdpBitmapCache* bitmap_cache, UINT32 id, UINT32 index, rdpBitmap* bitmap);
+static rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id,
+                                   UINT32 index);
+static void bitmap_cache_put(rdpBitmapCache* bitmap_cache, UINT32 id,
+                             UINT32 index, rdpBitmap* bitmap);
 
 static BOOL update_gdi_memblt(rdpContext* context,
-                                 MEMBLT_ORDER* memblt)
+                              MEMBLT_ORDER* memblt)
 {
        rdpBitmap* bitmap;
        rdpCache* cache = context->cache;
@@ -47,7 +49,9 @@ static BOOL update_gdi_memblt(rdpContext* context,
        if (memblt->cacheId == 0xFF)
                bitmap = offscreen_cache_get(cache->offscreen, memblt->cacheIndex);
        else
-               bitmap = bitmap_cache_get(cache->bitmap, (BYTE) memblt->cacheId, memblt->cacheIndex);
+               bitmap = bitmap_cache_get(cache->bitmap, (BYTE) memblt->cacheId,
+                                         memblt->cacheIndex);
+
        /* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
        if (bitmap == NULL)
                return TRUE;
@@ -57,7 +61,7 @@ static BOOL update_gdi_memblt(rdpContext* context,
 }
 
 static BOOL update_gdi_mem3blt(rdpContext* context,
-                                  MEM3BLT_ORDER* mem3blt)
+                               MEM3BLT_ORDER* mem3blt)
 {
        BYTE style;
        rdpBitmap* bitmap;
@@ -68,7 +72,8 @@ static BOOL update_gdi_mem3blt(rdpContext* context,
        if (mem3blt->cacheId == 0xFF)
                bitmap = offscreen_cache_get(cache->offscreen, mem3blt->cacheIndex);
        else
-               bitmap = bitmap_cache_get(cache->bitmap, (BYTE) mem3blt->cacheId, mem3blt->cacheIndex);
+               bitmap = bitmap_cache_get(cache->bitmap, (BYTE) mem3blt->cacheId,
+                                         mem3blt->cacheIndex);
 
        /* XP-SP2 servers sometimes ask for cached bitmaps they've never defined. */
        if (!bitmap)
@@ -79,8 +84,10 @@ static BOOL update_gdi_mem3blt(rdpContext* context,
        if (brush->style & CACHED_BRUSH)
        {
                brush->data = brush_cache_get(cache->brush, brush->index, &brush->bpp);
+
                if (!brush->data)
                        return FALSE;
+
                brush->style = 0x03;
        }
 
@@ -91,55 +98,58 @@ static BOOL update_gdi_mem3blt(rdpContext* context,
 }
 
 static BOOL update_gdi_cache_bitmap(rdpContext* context,
-                                const CACHE_BITMAP_ORDER* cacheBitmap)
+                                    const CACHE_BITMAP_ORDER* cacheBitmap)
 {
        rdpBitmap* bitmap;
        rdpBitmap* prevBitmap;
        rdpCache* cache = context->cache;
-
        bitmap = Bitmap_Alloc(context);
+
        if (!bitmap)
                return FALSE;
 
-
-       Bitmap_SetDimensions(context, bitmap, cacheBitmap->bitmapWidth, cacheBitmap->bitmapHeight);
+       Bitmap_SetDimensions(bitmap, cacheBitmap->bitmapWidth,
+                            cacheBitmap->bitmapHeight);
 
        if (!bitmap->Decompress(context, bitmap,
-                       cacheBitmap->bitmapDataStream, cacheBitmap->bitmapWidth, cacheBitmap->bitmapHeight,
-                       cacheBitmap->bitmapBpp, cacheBitmap->bitmapLength,
-                       cacheBitmap->compressed, RDP_CODEC_ID_NONE))
+                               cacheBitmap->bitmapDataStream, cacheBitmap->bitmapWidth,
+                               cacheBitmap->bitmapHeight,
+                               cacheBitmap->bitmapBpp, cacheBitmap->bitmapLength,
+                               cacheBitmap->compressed, RDP_CODEC_ID_NONE))
        {
-               Bitmap_Free(context, bitmap);
+               bitmap->Free(context, bitmap);
                return FALSE;
        }
 
        if (!bitmap->New(context, bitmap))
                return FALSE;
 
-       prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex);
+       prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmap->cacheId,
+                                     cacheBitmap->cacheIndex);
 
        if (prevBitmap != NULL)
                prevBitmap->Free(context, prevBitmap);
 
-
-       bitmap_cache_put(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex, bitmap);
+       bitmap_cache_put(cache->bitmap, cacheBitmap->cacheId, cacheBitmap->cacheIndex,
+                        bitmap);
        return TRUE;
 }
 
 static BOOL update_gdi_cache_bitmap_v2(rdpContext* context,
-                                          CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
+                                       CACHE_BITMAP_V2_ORDER* cacheBitmapV2)
 
 {
        rdpBitmap* bitmap;
        rdpBitmap* prevBitmap;
        rdpCache* cache = context->cache;
        rdpSettings* settings = context->settings;
-
        bitmap = Bitmap_Alloc(context);
+
        if (!bitmap)
                return FALSE;
 
-       Bitmap_SetDimensions(context, bitmap, cacheBitmapV2->bitmapWidth, cacheBitmapV2->bitmapHeight);
+       Bitmap_SetDimensions(bitmap, cacheBitmapV2->bitmapWidth,
+                            cacheBitmapV2->bitmapHeight);
 
        if (!cacheBitmapV2->bitmapBpp)
                cacheBitmapV2->bitmapBpp = settings->ColorDepth;
@@ -148,20 +158,20 @@ static BOOL update_gdi_cache_bitmap_v2(rdpContext* context,
                cacheBitmapV2->bitmapBpp = settings->ColorDepth;
 
        if (!bitmap->Decompress(context, bitmap,
-                               cacheBitmapV2->bitmapDataStream,
-                               cacheBitmapV2->bitmapWidth,
-                               cacheBitmapV2->bitmapHeight,
-                               cacheBitmapV2->bitmapBpp,
-                               cacheBitmapV2->bitmapLength,
-                               cacheBitmapV2->compressed,
-                               RDP_CODEC_ID_NONE))
+                               cacheBitmapV2->bitmapDataStream,
+                               cacheBitmapV2->bitmapWidth,
+                               cacheBitmapV2->bitmapHeight,
+                               cacheBitmapV2->bitmapBpp,
+                               cacheBitmapV2->bitmapLength,
+                               cacheBitmapV2->compressed,
+                               RDP_CODEC_ID_NONE))
        {
-               Bitmap_Free(context, bitmap);
+               bitmap->Free(context, bitmap);
                return FALSE;
        }
 
-
-       prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV2->cacheId, cacheBitmapV2->cacheIndex);
+       prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV2->cacheId,
+                                     cacheBitmapV2->cacheIndex);
 
        if (!bitmap->New(context, bitmap))
                return FALSE;
@@ -169,12 +179,13 @@ static BOOL update_gdi_cache_bitmap_v2(rdpContext* context,
        if (prevBitmap)
                prevBitmap->Free(context, prevBitmap);
 
-       bitmap_cache_put(cache->bitmap, cacheBitmapV2->cacheId, cacheBitmapV2->cacheIndex, bitmap);
+       bitmap_cache_put(cache->bitmap, cacheBitmapV2->cacheId,
+                        cacheBitmapV2->cacheIndex, bitmap);
        return TRUE;
 }
 
 static BOOL update_gdi_cache_bitmap_v3(rdpContext* context,
-                                          CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
+                                       CACHE_BITMAP_V3_ORDER* cacheBitmapV3)
 {
        rdpBitmap* bitmap;
        rdpBitmap* prevBitmap;
@@ -182,37 +193,38 @@ static BOOL update_gdi_cache_bitmap_v3(rdpContext* context,
        rdpCache* cache = context->cache;
        rdpSettings* settings = context->settings;
        BITMAP_DATA_EX* bitmapData = &cacheBitmapV3->bitmapData;
-
        bitmap = Bitmap_Alloc(context);
+
        if (!bitmap)
                return FALSE;
 
-       Bitmap_SetDimensions(context, bitmap, bitmapData->width, bitmapData->height);
+       Bitmap_SetDimensions(bitmap, bitmapData->width, bitmapData->height);
 
        if (!cacheBitmapV3->bpp)
                cacheBitmapV3->bpp = settings->ColorDepth;
 
        compressed = (bitmapData->codecID != RDP_CODEC_ID_NONE);
-
        bitmap->Decompress(context, bitmap,
-                       bitmapData->data, bitmap->width, bitmap->height,
-                       bitmapData->bpp, bitmapData->length, compressed,
-                       bitmapData->codecID);
+                          bitmapData->data, bitmap->width, bitmap->height,
+                          bitmapData->bpp, bitmapData->length, compressed,
+                          bitmapData->codecID);
 
        if (!bitmap->New(context, bitmap))
                return FALSE;
 
-       prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV3->cacheId, cacheBitmapV3->cacheIndex);
+       prevBitmap = bitmap_cache_get(cache->bitmap, cacheBitmapV3->cacheId,
+                                     cacheBitmapV3->cacheIndex);
 
        if (prevBitmap)
                prevBitmap->Free(context, prevBitmap);
 
-       bitmap_cache_put(cache->bitmap, cacheBitmapV3->cacheId, cacheBitmapV3->cacheIndex, bitmap);
+       bitmap_cache_put(cache->bitmap, cacheBitmapV3->cacheId,
+                        cacheBitmapV3->cacheIndex, bitmap);
        return TRUE;
 }
 
 static BOOL update_gdi_bitmap_update(rdpContext* context,
-                                        const BITMAP_UPDATE* bitmapUpdate)
+                                     const BITMAP_UPDATE* bitmapUpdate)
 {
        UINT32 i;
        BOOL reused = TRUE;
@@ -231,36 +243,35 @@ static BOOL update_gdi_bitmap_update(rdpContext* context,
        for (i = 0; i < (int) bitmapUpdate->number; i++)
        {
                const BITMAP_DATA* bitmapData = &bitmapUpdate->rectangles[i];
-
                bitmap->format = gdi_get_pixel_format(bitmapData->bitsPerPixel, FALSE);
                bitmap->length = bitmapData->bitmapLength;
                bitmap->compressed = bitmapData->compressed;
-
-               Bitmap_SetRectangle(context, bitmap,
-                               bitmapData->destLeft, bitmapData->destTop,
-                               bitmapData->destRight, bitmapData->destBottom);
-
-               Bitmap_SetDimensions(context, bitmap, bitmapData->width, bitmapData->height);
-
+               Bitmap_SetRectangle(bitmap,
+                                   bitmapData->destLeft, bitmapData->destTop,
+                                   bitmapData->destRight, bitmapData->destBottom);
+               Bitmap_SetDimensions(bitmap, bitmapData->width, bitmapData->height);
                bitmap->Decompress(context, bitmap,
-                               bitmapData->bitmapDataStream, bitmapData->width, bitmapData->height,
-                               bitmapData->bitsPerPixel, bitmapData->bitmapLength,
-                               bitmapData->compressed, RDP_CODEC_ID_NONE);
+                                  bitmapData->bitmapDataStream, bitmapData->width, bitmapData->height,
+                                  bitmapData->bitsPerPixel, bitmapData->bitmapLength,
+                                  bitmapData->compressed, RDP_CODEC_ID_NONE);
 
                if (reused)
                        bitmap->Free(context, bitmap);
 
                reused = TRUE;
+
                if (!bitmap->New(context, bitmap))
                        return FALSE;
 
                if (!bitmap->Paint(context, bitmap))
                        return FALSE;
        }
+
        return TRUE;
 }
 
-rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index)
+rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id,
+                            UINT32 index)
 {
        rdpBitmap* bitmap;
 
@@ -281,11 +292,11 @@ rdpBitmap* bitmap_cache_get(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index
        }
 
        bitmap = bitmapCache->cells[id].entries[index];
-
        return bitmap;
 }
 
-void bitmap_cache_put(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index, rdpBitmap* bitmap)
+void bitmap_cache_put(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index,
+                      rdpBitmap* bitmap)
 {
        if (id > bitmapCache->maxCells)
        {
@@ -309,17 +320,13 @@ void bitmap_cache_put(rdpBitmapCache* bitmapCache, UINT32 id, UINT32 index, rdpB
 void bitmap_cache_register_callbacks(rdpUpdate* update)
 {
        rdpCache* cache = update->context->cache;
-
        cache->bitmap->MemBlt = update->primary->MemBlt;
        cache->bitmap->Mem3Blt = update->primary->Mem3Blt;
-
        update->primary->MemBlt = update_gdi_memblt;
        update->primary->Mem3Blt = update_gdi_mem3blt;
-
        update->secondary->CacheBitmap = update_gdi_cache_bitmap;
        update->secondary->CacheBitmapV2 = update_gdi_cache_bitmap_v2;
        update->secondary->CacheBitmapV3 = update_gdi_cache_bitmap_v3;
-
        update->BitmapUpdate = update_gdi_bitmap_update;
 }
 
@@ -327,7 +334,6 @@ rdpBitmapCache* bitmap_cache_new(rdpSettings* settings)
 {
        int i;
        rdpBitmapCache* bitmapCache;
-
        bitmapCache = (rdpBitmapCache*) calloc(1, sizeof(rdpBitmapCache));
 
        if (bitmapCache)
@@ -335,10 +341,9 @@ rdpBitmapCache* bitmap_cache_new(rdpSettings* settings)
                bitmapCache->settings = settings;
                bitmapCache->update = ((freerdp*) settings->instance)->update;
                bitmapCache->context = bitmapCache->update->context;
-
                bitmapCache->maxCells = settings->BitmapCacheV2NumCells;
-
-               bitmapCache->cells = (BITMAP_V2_CELL*) calloc(bitmapCache->maxCells, sizeof(BITMAP_V2_CELL));
+               bitmapCache->cells = (BITMAP_V2_CELL*) calloc(bitmapCache->maxCells,
+                                    sizeof(BITMAP_V2_CELL));
 
                if (!bitmapCache->cells)
                {
@@ -350,7 +355,8 @@ rdpBitmapCache* bitmap_cache_new(rdpSettings* settings)
                {
                        bitmapCache->cells[i].number = settings->BitmapCacheV2CellInfo[i].numEntries;
                        /* allocate an extra entry for BITMAP_CACHE_WAITING_LIST_INDEX */
-                       bitmapCache->cells[i].entries = (rdpBitmap**) calloc((bitmapCache->cells[i].number + 1), sizeof(rdpBitmap*));
+                       bitmapCache->cells[i].entries = (rdpBitmap**) calloc((
+                                                           bitmapCache->cells[i].number + 1), sizeof(rdpBitmap*));
                }
        }
 
@@ -371,14 +377,14 @@ void bitmap_cache_free(rdpBitmapCache* bitmapCache)
                                bitmap = bitmapCache->cells[i].entries[j];
 
                                if (bitmap)
-                                       Bitmap_Free(bitmapCache->context, bitmap);
+                                       bitmap->Free(bitmapCache->context, bitmap);
                        }
 
                        free(bitmapCache->cells[i].entries);
                }
 
                if (bitmapCache->bitmap)
-                       Bitmap_Free(bitmapCache->context, bitmapCache->bitmap);
+                       bitmapCache->bitmap->Free(bitmapCache->context, bitmapCache->bitmap);
 
                free(bitmapCache->cells);
                free(bitmapCache);

diff --git a/libfreerdp/cache/offscreen.c b/libfreerdp/cache/offscreen.c
index ace0cc0..62cf5ee 100644 (file)
--- a/libfreerdp/cache/offscreen.c
+++ b/libfreerdp/cache/offscreen.c
@@ -61,7 +61,7 @@ static BOOL update_gdi_create_offscreen_bitmap(rdpContext* context,
        offscreen_cache_put(cache->offscreen, createOffscreenBitmap->id, bitmap);
 
        if (cache->offscreen->currentSurface == createOffscreenBitmap->id)
-               Bitmap_SetSurface(context, bitmap, FALSE);
+               bitmap->SetSurface(context, bitmap, FALSE);
 
        for (i = 0; i < createOffscreenBitmap->deleteList.cIndices; i++)
        {
@@ -76,16 +76,17 @@ static BOOL update_gdi_switch_surface(rdpContext* context,
                                       const SWITCH_SURFACE_ORDER* switchSurface)
 {
        rdpCache* cache = context->cache;
+       rdpBitmap* bitmap = context->graphics->Bitmap_Prototype;
 
        if (switchSurface->bitmapId == SCREEN_BITMAP_SURFACE)
        {
-               Bitmap_SetSurface(context, NULL, TRUE);
+               bitmap->SetSurface(context, NULL, TRUE);
        }
        else
        {
                rdpBitmap* bitmap;
                bitmap = offscreen_cache_get(cache->offscreen, switchSurface->bitmapId);
-               Bitmap_SetSurface(context, bitmap, FALSE);
+               bitmap->SetSurface(context, bitmap, FALSE);
        }
 
        cache->offscreen->currentSurface = switchSurface->bitmapId;
@@ -139,7 +140,7 @@ void offscreen_cache_delete(rdpOffscreenCache* offscreenCache, UINT32 index)
        prevBitmap = offscreenCache->entries[index];
 
        if (prevBitmap != NULL)
-               Bitmap_Free(offscreenCache->update->context, prevBitmap);
+               prevBitmap->Free(offscreenCache->update->context, prevBitmap);
 
        offscreenCache->entries[index] = NULL;
 }
@@ -189,7 +190,7 @@ void offscreen_cache_free(rdpOffscreenCache* offscreenCache)
                        bitmap = offscreenCache->entries[i];
 
                        if (bitmap)
-                               Bitmap_Free(offscreenCache->update->context, bitmap);
+                               bitmap->Free(offscreenCache->update->context, bitmap);
                }
 
                free(offscreenCache->entries);

diff --git a/libfreerdp/core/graphics.c b/libfreerdp/core/graphics.c
index cb61446..0079c9c 100644 (file)
--- a/libfreerdp/core/graphics.c
+++ b/libfreerdp/core/graphics.c
@@ -43,12 +43,16 @@ rdpBitmap* Bitmap_Alloc(rdpContext* context)
        return bitmap;
 }
 
-BOOL Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
+static BOOL Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
 {
+       if (!bitmap || !context)
+               return FALSE;
+
+       *bitmap = *context->graphics->Bitmap_Prototype;
        return TRUE;
 }
 
-void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
+static void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
 {
        if (bitmap)
        {
@@ -61,27 +65,30 @@ void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
        }
 }
 
-void Bitmap_SetRectangle(rdpContext* context, rdpBitmap* bitmap, UINT16 left,
+BOOL Bitmap_SetRectangle(rdpBitmap* bitmap,
+                         UINT16 left,
                          UINT16 top, UINT16 right, UINT16 bottom)
 {
+       if (!bitmap)
+               return FALSE;
+
        bitmap->left = left;
        bitmap->top = top;
        bitmap->right = right;
        bitmap->bottom = bottom;
+       return TRUE;
 }
 
-void Bitmap_SetDimensions(rdpContext* context, rdpBitmap* bitmap, UINT16 width,
+BOOL Bitmap_SetDimensions(rdpBitmap* bitmap,
+                          UINT16 width,
                           UINT16 height)
 {
+       if (!bitmap)
+               return FALSE;
+
        bitmap->width = width;
        bitmap->height = height;
-}
-
-/* static method */
-BOOL Bitmap_SetSurface(rdpContext* context, rdpBitmap* bitmap, BOOL primary)
-{
-       return context->graphics->Bitmap_Prototype->SetSurface(context, bitmap,
-               primary);
+       return TRUE;
 }
 
 void graphics_register_bitmap(rdpGraphics* graphics, rdpBitmap* bitmap)