dlls/winemac.drv/surface.c

   1 /*
   2  * Mac driver window surface implementation
   3  *
   4  * Copyright 1993, 1994, 2011 Alexandre Julliard
   5  * Copyright 2006 Damjan Jovanovic
   6  * Copyright 2012, 2013 Ken Thomases for CodeWeavers, Inc.
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24
  25 #include "macdrv.h"
  26 #include "winuser.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(macdrv);
  29
  30
  31 /* only for use on sanitized BITMAPINFO structures */
  32 static inline int get_dib_info_size(const BITMAPINFO *info, UINT coloruse)
  33 {
  34     if (info->bmiHeader.biCompression == BI_BITFIELDS)
  35         return sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD);
  36     if (coloruse == DIB_PAL_COLORS)
  37         return sizeof(BITMAPINFOHEADER) + info->bmiHeader.biClrUsed * sizeof(WORD);
  38     return FIELD_OFFSET(BITMAPINFO, bmiColors[info->bmiHeader.biClrUsed]);
  39 }
  40
  41 static inline int get_dib_stride(int width, int bpp)
  42 {
  43     return ((width * bpp + 31) >> 3) & ~3;
  44 }
  45
  46 static inline int get_dib_image_size(const BITMAPINFO *info)
  47 {
  48     return get_dib_stride(info->bmiHeader.biWidth, info->bmiHeader.biBitCount)
  49         * abs(info->bmiHeader.biHeight);
  50 }
  51
  52 static inline void reset_bounds(RECT *bounds)
  53 {
  54     bounds->left = bounds->top = INT_MAX;
  55     bounds->right = bounds->bottom = INT_MIN;
  56 }
  57
  58
  59 struct macdrv_window_surface
  60 {
  61     struct window_surface   header;
  62     macdrv_window           window;
  63     RECT                    bounds;
  64     HRGN                    region;
  65     HRGN                    drawn;
  66     BOOL                    use_alpha;
  67     RGNDATA                *blit_data;
  68     BYTE                   *bits;
  69     pthread_mutex_t         mutex;
  70     BITMAPINFO              info;   /* variable size, must be last */
  71 };
  72
  73 static struct macdrv_window_surface *get_mac_surface(struct window_surface *surface);
  74
  75 /***********************************************************************
  76  *              update_blit_data
  77  */
  78 static void update_blit_data(struct macdrv_window_surface *surface)
  79 {
  80     HeapFree(GetProcessHeap(), 0, surface->blit_data);
  81     surface->blit_data = NULL;
  82
  83     if (surface->drawn)
  84     {
  85         HRGN blit = CreateRectRgn(0, 0, 0, 0);
  86
  87         if (CombineRgn(blit, surface->drawn, 0, RGN_COPY) > NULLREGION &&
  88             (!surface->region || CombineRgn(blit, blit, surface->region, RGN_AND) > NULLREGION) &&
  89             OffsetRgn(blit, surface->header.rect.left, surface->header.rect.top) > NULLREGION)
  90             surface->blit_data = get_region_data(blit, 0);
  91
  92         DeleteObject(blit);
  93     }
  94 }
  95
  96 /***********************************************************************
  97  *              macdrv_surface_lock
  98  */
  99 static void CDECL macdrv_surface_lock(struct window_surface *window_surface)
 100 {
 101     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 102
 103     pthread_mutex_lock(&surface->mutex);
 104 }
 105
 106 /***********************************************************************
 107  *              macdrv_surface_unlock
 108  */
 109 static void CDECL macdrv_surface_unlock(struct window_surface *window_surface)
 110 {
 111     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 112
 113     pthread_mutex_unlock(&surface->mutex);
 114 }
 115
 116 /***********************************************************************
 117  *              macdrv_surface_get_bitmap_info
 118  */
 119 static void *CDECL macdrv_surface_get_bitmap_info(struct window_surface *window_surface,
 120                                                   BITMAPINFO *info)
 121 {
 122     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 123
 124     memcpy(info, &surface->info, get_dib_info_size(&surface->info, DIB_RGB_COLORS));
 125     return surface->bits;
 126 }
 127
 128 /***********************************************************************
 129  *              macdrv_surface_get_bounds
 130  */
 131 static RECT *CDECL macdrv_surface_get_bounds(struct window_surface *window_surface)
 132 {
 133     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 134
 135     return &surface->bounds;
 136 }
 137
 138 /***********************************************************************
 139  *              macdrv_surface_set_region
 140  */
 141 static void CDECL macdrv_surface_set_region(struct window_surface *window_surface, HRGN region)
 142 {
 143     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 144
 145     TRACE("updating surface %p with %p\n", surface, region);
 146
 147     window_surface->funcs->lock(window_surface);
 148
 149     if (region)
 150     {
 151         if (!surface->region) surface->region = CreateRectRgn(0, 0, 0, 0);
 152         CombineRgn(surface->region, region, 0, RGN_COPY);
 153     }
 154     else
 155     {
 156         if (surface->region) DeleteObject(surface->region);
 157         surface->region = 0;
 158     }
 159     update_blit_data(surface);
 160
 161     window_surface->funcs->unlock(window_surface);
 162 }
 163
 164 /***********************************************************************
 165  *              macdrv_surface_flush
 166  */
 167 static void CDECL macdrv_surface_flush(struct window_surface *window_surface)
 168 {
 169     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 170     CGRect rect;
 171     HRGN region;
 172
 173     window_surface->funcs->lock(window_surface);
 174
 175     TRACE("flushing %p %s bounds %s bits %p\n", surface, wine_dbgstr_rect(&surface->header.rect),
 176           wine_dbgstr_rect(&surface->bounds), surface->bits);
 177
 178     rect = cgrect_from_rect(surface->bounds);
 179     rect = CGRectOffset(rect, surface->header.rect.left, surface->header.rect.top);
 180
 181     if (!IsRectEmpty(&surface->bounds) && (region = CreateRectRgnIndirect(&surface->bounds)))
 182     {
 183         if (surface->drawn)
 184         {
 185             CombineRgn(surface->drawn, surface->drawn, region, RGN_OR);
 186             DeleteObject(region);
 187         }
 188         else
 189             surface->drawn = region;
 190     }
 191     update_blit_data(surface);
 192     reset_bounds(&surface->bounds);
 193
 194     window_surface->funcs->unlock(window_surface);
 195
 196     if (!CGRectIsEmpty(rect))
 197         macdrv_window_needs_display(surface->window, rect);
 198 }
 199
 200 /***********************************************************************
 201  *              macdrv_surface_destroy
 202  */
 203 static void CDECL macdrv_surface_destroy(struct window_surface *window_surface)
 204 {
 205     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 206
 207     TRACE("freeing %p bits %p\n", surface, surface->bits);
 208     if (surface->region) DeleteObject(surface->region);
 209     if (surface->drawn) DeleteObject(surface->drawn);
 210     HeapFree(GetProcessHeap(), 0, surface->blit_data);
 211     HeapFree(GetProcessHeap(), 0, surface->bits);
 212     pthread_mutex_destroy(&surface->mutex);
 213     HeapFree(GetProcessHeap(), 0, surface);
 214 }
 215
 216 static const struct window_surface_funcs macdrv_surface_funcs =
 217 {
 218     macdrv_surface_lock,
 219     macdrv_surface_unlock,
 220     macdrv_surface_get_bitmap_info,
 221     macdrv_surface_get_bounds,
 222     macdrv_surface_set_region,
 223     macdrv_surface_flush,
 224     macdrv_surface_destroy,
 225 };
 226
 227 static struct macdrv_window_surface *get_mac_surface(struct window_surface *surface)
 228 {
 229     if (!surface || surface->funcs != &macdrv_surface_funcs) return NULL;
 230     return (struct macdrv_window_surface *)surface;
 231 }
 232
 233 /***********************************************************************
 234  *              create_surface
 235  */
 236 struct window_surface *create_surface(macdrv_window window, const RECT *rect,
 237                                       struct window_surface *old_surface, BOOL use_alpha)
 238 {
 239     struct macdrv_window_surface *surface;
 240     struct macdrv_window_surface *old_mac_surface = get_mac_surface(old_surface);
 241     int width = rect->right - rect->left, height = rect->bottom - rect->top;
 242     DWORD *colors;
 243     pthread_mutexattr_t attr;
 244     int err;
 245     DWORD window_background;
 246
 247     surface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 248                         FIELD_OFFSET(struct macdrv_window_surface, info.bmiColors[3]));
 249     if (!surface) return NULL;
 250
 251     err = pthread_mutexattr_init(&attr);
 252     if (!err)
 253     {
 254         err = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
 255         if (!err)
 256             err = pthread_mutex_init(&surface->mutex, &attr);
 257         pthread_mutexattr_destroy(&attr);
 258     }
 259     if (err)
 260     {
 261         HeapFree(GetProcessHeap(), 0, surface);
 262         return NULL;
 263     }
 264
 265     surface->info.bmiHeader.biSize        = sizeof(surface->info.bmiHeader);
 266     surface->info.bmiHeader.biWidth       = width;
 267     surface->info.bmiHeader.biHeight      = height; /* bottom-up */
 268     surface->info.bmiHeader.biPlanes      = 1;
 269     surface->info.bmiHeader.biBitCount    = 32;
 270     surface->info.bmiHeader.biSizeImage   = get_dib_image_size(&surface->info);
 271     surface->info.bmiHeader.biCompression = BI_RGB;
 272     surface->info.bmiHeader.biClrUsed     = 0;
 273
 274     colors = (DWORD *)((char *)&surface->info + surface->info.bmiHeader.biSize);
 275     colors[0] = 0x00ff0000;
 276     colors[1] = 0x0000ff00;
 277     colors[2] = 0x000000ff;
 278
 279     surface->header.funcs = &macdrv_surface_funcs;
 280     surface->header.rect  = *rect;
 281     surface->header.ref   = 1;
 282     surface->window = window;
 283     reset_bounds(&surface->bounds);
 284     if (old_mac_surface && old_mac_surface->drawn)
 285     {
 286         surface->drawn = CreateRectRgnIndirect(rect);
 287         OffsetRgn(surface->drawn, -rect->left, -rect->top);
 288         if (CombineRgn(surface->drawn, surface->drawn, old_mac_surface->drawn, RGN_AND) <= NULLREGION)
 289         {
 290             DeleteObject(surface->drawn);
 291             surface->drawn = 0;
 292         }
 293     }
 294     update_blit_data(surface);
 295     surface->use_alpha = use_alpha;
 296     surface->bits = HeapAlloc(GetProcessHeap(), 0, surface->info.bmiHeader.biSizeImage);
 297     if (!surface->bits) goto failed;
 298     window_background = macdrv_window_background_color();
 299     memset_pattern4(surface->bits, &window_background, surface->info.bmiHeader.biSizeImage);
 300
 301     TRACE("created %p for %p %s bits %p-%p\n", surface, window, wine_dbgstr_rect(rect),
 302           surface->bits, surface->bits + surface->info.bmiHeader.biSizeImage);
 303
 304     return &surface->header;
 305
 306 failed:
 307     macdrv_surface_destroy(&surface->header);
 308     return NULL;
 309 }
 310
 311 /***********************************************************************
 312  *              set_surface_use_alpha
 313  */
 314 void set_surface_use_alpha(struct window_surface *window_surface, BOOL use_alpha)
 315 {
 316     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 317     if (surface) surface->use_alpha = use_alpha;
 318 }
 319
 320 /***********************************************************************
 321  *              set_window_surface
 322  */
 323 void set_window_surface(macdrv_window window, struct window_surface *window_surface)
 324 {
 325     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 326     macdrv_set_window_surface(window, window_surface, surface ? &surface->mutex : NULL);
 327 }
 328
 329 /***********************************************************************
 330  *              get_surface_blit_rects
 331  *
 332  * Caller must hold the surface lock.  Indirectly returns the surface
 333  * blit region rects.  Returns zero if the surface has nothing to blit;
 334  * returns non-zero if the surface does have rects to blit (drawn area
 335  * which isn't clipped away by a surface region).
 336  *
 337  * IMPORTANT: This function is called from non-Wine threads, so it
 338  *            must not use Win32 or Wine functions, including debug
 339  *            logging.
 340  */
 341 int get_surface_blit_rects(void *window_surface, const CGRect **rects, int *count)
 342 {
 343     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 344
 345     if (surface->blit_data)
 346     {
 347         *rects = (const CGRect*)surface->blit_data->Buffer;
 348         *count = surface->blit_data->rdh.nCount;
 349     }
 350     else
 351     {
 352         *rects = NULL;
 353         *count = 0;
 354     }
 355
 356     return (surface->blit_data != NULL);
 357 }
 358
 359 /***********************************************************************
 360  *              create_surface_image
 361  *
 362  * Caller must hold the surface lock.  On input, *rect is the requested
 363  * image rect, relative to the window whole_rect, a.k.a. visible_rect.
 364  * On output, it's been intersected with that part backed by the surface
 365  * and is the actual size of the returned image.  copy_data indicates if
 366  * the caller will keep the returned image beyond the point where the
 367  * surface bits can be guaranteed to remain valid and unchanged.  If so,
 368  * the bits are copied instead of merely referenced by the image.
 369  *
 370  * IMPORTANT: This function is called from non-Wine threads, so it
 371  *            must not use Win32 or Wine functions, including debug
 372  *            logging.
 373  */
 374 CGImageRef create_surface_image(void *window_surface, CGRect *rect, int copy_data)
 375 {
 376     CGImageRef cgimage = NULL;
 377     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 378     int width, height;
 379
 380     width  = surface->header.rect.right - surface->header.rect.left;
 381     height = surface->header.rect.bottom - surface->header.rect.top;
 382     *rect = CGRectIntersection(cgrect_from_rect(surface->header.rect), *rect);
 383     if (!CGRectIsEmpty(*rect))
 384     {
 385         CGRect visrect;
 386         CGColorSpaceRef colorspace;
 387         CGDataProviderRef provider;
 388         int bytes_per_row, offset, size;
 389         CGImageAlphaInfo alphaInfo;
 390
 391         visrect = CGRectOffset(*rect, -surface->header.rect.left, -surface->header.rect.top);
 392
 393         colorspace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
 394         bytes_per_row = get_dib_stride(width, 32);
 395         offset = CGRectGetMinX(visrect) * 4 + (height - CGRectGetMaxY(visrect)) * bytes_per_row;
 396         size = min(CGRectGetHeight(visrect) * bytes_per_row,
 397                    surface->info.bmiHeader.biSizeImage - offset);
 398
 399         if (copy_data)
 400         {
 401             CFDataRef data = CFDataCreate(NULL, (UInt8*)surface->bits + offset, size);
 402             provider = CGDataProviderCreateWithCFData(data);
 403             CFRelease(data);
 404         }
 405         else
 406             provider = CGDataProviderCreateWithData(NULL, surface->bits + offset, size, NULL);
 407
 408         alphaInfo = surface->use_alpha ? kCGImageAlphaPremultipliedFirst : kCGImageAlphaNoneSkipFirst;
 409         cgimage = CGImageCreate(CGRectGetWidth(visrect), CGRectGetHeight(visrect),
 410                                 8, 32, bytes_per_row, colorspace,
 411                                 alphaInfo | kCGBitmapByteOrder32Little,
 412                                 provider, NULL, retina_on, kCGRenderingIntentDefault);
 413         CGDataProviderRelease(provider);
 414         CGColorSpaceRelease(colorspace);
 415     }
 416
 417     return cgimage;
 418 }
 419
 420 /***********************************************************************
 421  *              surface_clip_to_visible_rect
 422  *
 423  * Intersect the accumulated drawn region with a new visible rect,
 424  * effectively discarding stale drawing in the surface slack area.
 425  */
 426 void surface_clip_to_visible_rect(struct window_surface *window_surface, const RECT *visible_rect)
 427 {
 428     struct macdrv_window_surface *surface = get_mac_surface(window_surface);
 429
 430     if (!surface) return;
 431     window_surface->funcs->lock(window_surface);
 432
 433     if (surface->drawn)
 434     {
 435         RECT rect;
 436         HRGN region;
 437
 438         rect = *visible_rect;
 439         OffsetRect(&rect, -rect.left, -rect.top);
 440
 441         if ((region = CreateRectRgnIndirect(&rect)))
 442         {
 443             CombineRgn(surface->drawn, surface->drawn, region, RGN_AND);
 444             DeleteObject(region);
 445
 446             update_blit_data(surface);
 447         }
 448     }
 449
 450     window_surface->funcs->unlock(window_surface);
 451 }