dlls/mscms/handle.c

   1 /*
   2  * MSCMS - Color Management System for Wine
   3  *
   4  * Copyright 2004, 2005, 2008 Hans Leidekker
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/debug.h"
  23
  24 #include <stdarg.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "icm.h"
  31
  32 #include "mscms_priv.h"
  33
  34 #ifdef HAVE_LCMS
  35
  36 static CRITICAL_SECTION MSCMS_handle_cs;
  37 static CRITICAL_SECTION_DEBUG MSCMS_handle_cs_debug =
  38 {
  39     0, 0, &MSCMS_handle_cs,
  40     { &MSCMS_handle_cs_debug.ProcessLocksList,
  41       &MSCMS_handle_cs_debug.ProcessLocksList },
  42       0, 0, { (DWORD_PTR)(__FILE__ ": MSCMS_handle_cs") }
  43 };
  44 static CRITICAL_SECTION MSCMS_handle_cs = { &MSCMS_handle_cs_debug, -1, 0, 0, 0, 0 };
  45
  46 static struct profile *profiletable;
  47 static struct transform *transformtable;
  48
  49 static unsigned int num_profile_handles;
  50 static unsigned int num_transform_handles;
  51
  52 WINE_DEFAULT_DEBUG_CHANNEL(mscms);
  53
  54 void free_handle_tables( void )
  55 {
  56     HeapFree( GetProcessHeap(), 0, profiletable );
  57     profiletable = NULL;
  58     num_profile_handles = 0;
  59
  60     HeapFree( GetProcessHeap(), 0, transformtable );
  61     transformtable = NULL;
  62     num_transform_handles = 0;
  63
  64     DeleteCriticalSection( &MSCMS_handle_cs );
  65 }
  66
  67 struct profile *grab_profile( HPROFILE handle )
  68 {
  69     DWORD_PTR index;
  70
  71     EnterCriticalSection( &MSCMS_handle_cs );
  72
  73     index = (DWORD_PTR)handle - 1;
  74     if (index > num_profile_handles)
  75     {
  76         LeaveCriticalSection( &MSCMS_handle_cs );
  77         return NULL;
  78     }
  79     return &profiletable[index];
  80 }
  81
  82 void release_profile( struct profile *profile )
  83 {
  84     LeaveCriticalSection( &MSCMS_handle_cs );
  85 }
  86
  87 struct transform *grab_transform( HTRANSFORM handle )
  88 {
  89     DWORD_PTR index;
  90
  91     EnterCriticalSection( &MSCMS_handle_cs );
  92
  93     index = (DWORD_PTR)handle - 1;
  94     if (index > num_transform_handles)
  95     {
  96         LeaveCriticalSection( &MSCMS_handle_cs );
  97         return NULL;
  98     }
  99     return &transformtable[index];
 100 }
 101
 102 void release_transform( struct transform *transform )
 103 {
 104     LeaveCriticalSection( &MSCMS_handle_cs );
 105 }
 106
 107 static HPROFILE alloc_profile_handle( void )
 108 {
 109     DWORD_PTR index;
 110     struct profile *p;
 111     unsigned int count = 128;
 112
 113     for (index = 0; index < num_profile_handles; index++)
 114     {
 115         if (!profiletable[index].iccprofile) return (HPROFILE)(index + 1);
 116     }
 117     if (!profiletable)
 118     {
 119         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(struct profile) );
 120     }
 121     else
 122     {
 123         count = num_profile_handles * 2;
 124         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, profiletable, count * sizeof(struct profile) );
 125     }
 126     if (!p) return NULL;
 127
 128     profiletable = p;
 129     num_profile_handles = count;
 130
 131     return (HPROFILE)(index + 1);
 132 }
 133
 134 HPROFILE create_profile( struct profile *profile )
 135 {
 136     HPROFILE handle;
 137
 138     EnterCriticalSection( &MSCMS_handle_cs );
 139
 140     if ((handle = alloc_profile_handle()))
 141     {
 142         DWORD_PTR index = (DWORD_PTR)handle - 1;
 143         memcpy( &profiletable[index], profile, sizeof(struct profile) );
 144     }
 145     LeaveCriticalSection( &MSCMS_handle_cs );
 146     return handle;
 147 }
 148
 149 BOOL close_profile( HPROFILE handle )
 150 {
 151     DWORD_PTR index;
 152     struct profile *profile;
 153
 154     EnterCriticalSection( &MSCMS_handle_cs );
 155
 156     index = (DWORD_PTR)handle - 1;
 157     if (index > num_profile_handles)
 158     {
 159         LeaveCriticalSection( &MSCMS_handle_cs );
 160         return FALSE;
 161     }
 162     profile = &profiletable[index];
 163
 164     if (profile->file != INVALID_HANDLE_VALUE)
 165     {
 166         if (profile->access & PROFILE_READWRITE)
 167         {
 168             DWORD written, size = MSCMS_get_profile_size( profile->iccprofile );
 169
 170             if (SetFilePointer( profile->file, 0, NULL, FILE_BEGIN ) ||
 171                 !WriteFile( profile->file, profile->iccprofile, size, &written, NULL ) ||
 172                 written != size)
 173             {
 174                 ERR( "Unable to write color profile\n" );
 175             }
 176         }
 177         CloseHandle( profile->file );
 178     }
 179     cmsCloseProfile( profile->cmsprofile );
 180     HeapFree( GetProcessHeap(), 0, profile->iccprofile );
 181
 182     memset( profile, 0, sizeof(struct profile) );
 183
 184     LeaveCriticalSection( &MSCMS_handle_cs );
 185     return TRUE;
 186 }
 187
 188 static HTRANSFORM alloc_transform_handle( void )
 189 {
 190     DWORD_PTR index;
 191     struct transform *p;
 192     unsigned int count = 128;
 193
 194     for (index = 0; index < num_transform_handles; index++)
 195     {
 196         if (!transformtable[index].cmstransform) return (HTRANSFORM)(index + 1);
 197     }
 198     if (!transformtable)
 199     {
 200         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(struct transform) );
 201     }
 202     else
 203     {
 204         count = num_transform_handles * 2;
 205         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, transformtable, count * sizeof(struct transform) );
 206     }
 207     if (!p) return NULL;
 208
 209     transformtable = p;
 210     num_transform_handles = count;
 211
 212     return (HTRANSFORM)(index + 1);
 213 }
 214
 215 HTRANSFORM create_transform( struct transform *transform )
 216 {
 217     HTRANSFORM handle;
 218
 219     EnterCriticalSection( &MSCMS_handle_cs );
 220
 221     if ((handle = alloc_transform_handle()))
 222     {
 223         DWORD_PTR index = (DWORD_PTR)handle - 1;
 224         memcpy( &transformtable[index], transform, sizeof(struct transform) );
 225     }
 226     LeaveCriticalSection( &MSCMS_handle_cs );
 227     return handle;
 228 }
 229
 230 BOOL close_transform( HTRANSFORM handle )
 231 {
 232     DWORD_PTR index;
 233     struct transform *transform;
 234
 235     EnterCriticalSection( &MSCMS_handle_cs );
 236
 237     index = (DWORD_PTR)handle - 1;
 238     if (index > num_transform_handles)
 239     {
 240         LeaveCriticalSection( &MSCMS_handle_cs );
 241         return FALSE;
 242     }
 243     transform = &transformtable[index];
 244
 245     cmsDeleteTransform( transform->cmstransform );
 246     memset( transform, 0, sizeof(struct transform) );
 247
 248     LeaveCriticalSection( &MSCMS_handle_cs );
 249     return TRUE;
 250 }
 251
 252 #endif /* HAVE_LCMS */