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 <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "winuser.h"
  27 #include "icm.h"
  28 #include "wine/debug.h"
  29
  30 #include "mscms_priv.h"
  31
  32 static CRITICAL_SECTION mscms_handle_cs;
  33 static CRITICAL_SECTION_DEBUG mscms_handle_cs_debug =
  34 {
  35     0, 0, &mscms_handle_cs,
  36     { &mscms_handle_cs_debug.ProcessLocksList,
  37       &mscms_handle_cs_debug.ProcessLocksList },
  38       0, 0, { (DWORD_PTR)(__FILE__ ": mscms_handle_cs") }
  39 };
  40 static CRITICAL_SECTION mscms_handle_cs = { &mscms_handle_cs_debug, -1, 0, 0, 0, 0 };
  41
  42 static struct profile *profiletable;
  43 static struct transform *transformtable;
  44
  45 static unsigned int num_profile_handles;
  46 static unsigned int num_transform_handles;
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(mscms);
  49
  50 void free_handle_tables( void )
  51 {
  52     HeapFree( GetProcessHeap(), 0, profiletable );
  53     profiletable = NULL;
  54     num_profile_handles = 0;
  55
  56     HeapFree( GetProcessHeap(), 0, transformtable );
  57     transformtable = NULL;
  58     num_transform_handles = 0;
  59
  60     DeleteCriticalSection( &mscms_handle_cs );
  61 }
  62
  63 struct profile *grab_profile( HPROFILE handle )
  64 {
  65     DWORD_PTR index;
  66
  67     EnterCriticalSection( &mscms_handle_cs );
  68
  69     index = (DWORD_PTR)handle - 1;
  70     if (index > num_profile_handles)
  71     {
  72         LeaveCriticalSection( &mscms_handle_cs );
  73         return NULL;
  74     }
  75     return &profiletable[index];
  76 }
  77
  78 void release_profile( struct profile *profile )
  79 {
  80     LeaveCriticalSection( &mscms_handle_cs );
  81 }
  82
  83 struct transform *grab_transform( HTRANSFORM handle )
  84 {
  85     DWORD_PTR index;
  86
  87     EnterCriticalSection( &mscms_handle_cs );
  88
  89     index = (DWORD_PTR)handle - 1;
  90     if (index > num_transform_handles)
  91     {
  92         LeaveCriticalSection( &mscms_handle_cs );
  93         return NULL;
  94     }
  95     return &transformtable[index];
  96 }
  97
  98 void release_transform( struct transform *transform )
  99 {
 100     LeaveCriticalSection( &mscms_handle_cs );
 101 }
 102
 103 static HPROFILE alloc_profile_handle( void )
 104 {
 105     DWORD_PTR index;
 106     struct profile *p;
 107     unsigned int count = 128;
 108
 109     for (index = 0; index < num_profile_handles; index++)
 110     {
 111         if (!profiletable[index].data) return (HPROFILE)(index + 1);
 112     }
 113     if (!profiletable)
 114     {
 115         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(struct profile) );
 116     }
 117     else
 118     {
 119         count = num_profile_handles * 2;
 120         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, profiletable, count * sizeof(struct profile) );
 121     }
 122     if (!p) return NULL;
 123
 124     profiletable = p;
 125     num_profile_handles = count;
 126
 127     return (HPROFILE)(index + 1);
 128 }
 129
 130 HPROFILE create_profile( struct profile *profile )
 131 {
 132     HPROFILE handle;
 133
 134     EnterCriticalSection( &mscms_handle_cs );
 135
 136     if ((handle = alloc_profile_handle()))
 137     {
 138         DWORD_PTR index = (DWORD_PTR)handle - 1;
 139         profiletable[index] = *profile;
 140     }
 141     LeaveCriticalSection( &mscms_handle_cs );
 142     return handle;
 143 }
 144
 145 BOOL close_profile( HPROFILE handle )
 146 {
 147     DWORD_PTR index;
 148     struct profile *profile;
 149
 150     EnterCriticalSection( &mscms_handle_cs );
 151
 152     index = (DWORD_PTR)handle - 1;
 153     if (index > num_profile_handles)
 154     {
 155         LeaveCriticalSection( &mscms_handle_cs );
 156         return FALSE;
 157     }
 158     profile = &profiletable[index];
 159
 160     if (profile->file != INVALID_HANDLE_VALUE)
 161     {
 162         if (profile->access & PROFILE_READWRITE)
 163         {
 164             DWORD written;
 165
 166             if (SetFilePointer( profile->file, 0, NULL, FILE_BEGIN ) ||
 167                 !WriteFile( profile->file, profile->data, profile->size, &written, NULL ) ||
 168                 written != profile->size)
 169             {
 170                 ERR( "Unable to write color profile\n" );
 171             }
 172         }
 173         CloseHandle( profile->file );
 174     }
 175     if (profile->cmsprofile) lcms_funcs->close_profile( profile->cmsprofile );
 176     HeapFree( GetProcessHeap(), 0, profile->data );
 177
 178     memset( profile, 0, sizeof(struct profile) );
 179
 180     LeaveCriticalSection( &mscms_handle_cs );
 181     return TRUE;
 182 }
 183
 184 static HTRANSFORM alloc_transform_handle( void )
 185 {
 186     DWORD_PTR index;
 187     struct transform *p;
 188     unsigned int count = 128;
 189
 190     for (index = 0; index < num_transform_handles; index++)
 191     {
 192         if (!transformtable[index].cmstransform) return (HTRANSFORM)(index + 1);
 193     }
 194     if (!transformtable)
 195     {
 196         p = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, count * sizeof(struct transform) );
 197     }
 198     else
 199     {
 200         count = num_transform_handles * 2;
 201         p = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, transformtable, count * sizeof(struct transform) );
 202     }
 203     if (!p) return NULL;
 204
 205     transformtable = p;
 206     num_transform_handles = count;
 207
 208     return (HTRANSFORM)(index + 1);
 209 }
 210
 211 HTRANSFORM create_transform( struct transform *transform )
 212 {
 213     HTRANSFORM handle;
 214
 215     EnterCriticalSection( &mscms_handle_cs );
 216
 217     if ((handle = alloc_transform_handle()))
 218     {
 219         DWORD_PTR index = (DWORD_PTR)handle - 1;
 220         transformtable[index] = *transform;
 221     }
 222     LeaveCriticalSection( &mscms_handle_cs );
 223     return handle;
 224 }
 225
 226 BOOL close_transform( HTRANSFORM handle )
 227 {
 228     DWORD_PTR index;
 229     struct transform *transform;
 230
 231     EnterCriticalSection( &mscms_handle_cs );
 232
 233     index = (DWORD_PTR)handle - 1;
 234     if (index > num_transform_handles)
 235     {
 236         LeaveCriticalSection( &mscms_handle_cs );
 237         return FALSE;
 238     }
 239     transform = &transformtable[index];
 240
 241     lcms_funcs->close_transform( transform->cmstransform );
 242
 243     memset( transform, 0, sizeof(struct transform) );
 244
 245     LeaveCriticalSection( &mscms_handle_cs );
 246     return TRUE;
 247 }