7472764b7df9a9da9d6075fd50df6a0ad1480914
[blender-staging.git] / source / blender / imbuf / intern / dynlibtiff.c
1 /**
2  * Dynamically loaded libtiff support.
3  *
4  * This file is automatically generated by the gen_dynlibtiff.py script.
5  * 
6  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * Contributor(s): Jonathan Merritt.
26  *
27  * ***** END GPL/BL DUAL LICENSE BLOCK *****
28  */
29  
30 /**
31  * To use the dynamic libtiff support, you must initialize the library using:
32  *      libtiff_init()
33  * This attempts to load libtiff dynamically at runtime.  G.have_libtiff will
34  * be set to indicate whether or not libtiff is available.  If libtiff is
35  * not available, Blender can proceed with no ill effects, provided that
36  * it does not attempt to use any of the libtiff_ functions.  When you're
37  * finished, close the library with:
38  *      libtiff_exit()
39  * These functions are both declared in IMB_imbuf.h
40  *
41  * The functions provided by dyn_libtiff.h are the same as those in the
42  * normal static / shared libtiff, except that they are prefixed by the 
43  * string "libtiff_" to indicate that they belong to a dynamically-loaded 
44  * version.
45  */
46 #include "dynlibtiff.h"
47
48 #include <assert.h>
49 #include <stdio.h>
50 #include <stdlib.h>
51
52 #include "BLI_blenlib.h"
53
54 #include "imbuf.h"
55 #include "imbuf_patch.h"
56 #include "IMB_imbuf.h"
57
58 #include "BKE_global.h"
59 #include "PIL_dynlib.h"
60
61 /*********************
62  * LOCAL DEFINITIONS *
63  *********************/
64 PILdynlib *libtiff = NULL;
65 void  libtiff_loadlibtiff(void);
66 void* libtiff_findsymbol(char*);
67 int   libtiff_load_symbols(void);
68
69
70 /**************************
71  * LIBRARY INITIALIZATION *
72  **************************/
73
74 void libtiff_loadlibtiff(void)
75 {
76         char *filename;
77         libtiff = NULL;
78
79 #ifndef __APPLE__       /* no standard location of libtiff in MacOS X */
80                                         /* declare env var if you want to use that */
81
82         /* Try to find libtiff in a couple of standard places */
83         libtiff = PIL_dynlib_open("libtiff.so");
84         if (libtiff != NULL)  return;
85         libtiff = PIL_dynlib_open("libtiff.dll");
86         if (libtiff != NULL)  return;
87         libtiff = PIL_dynlib_open("/usr/lib/libtiff.so");
88         if (libtiff != NULL)  return;
89         /* OSX has version specific library */
90         libtiff = PIL_dynlib_open("/usr/lib/libtiff.so.3");
91         if (libtiff != NULL)  return;
92         libtiff = PIL_dynlib_open("/usr/local/lib/libtiff.so");
93         if (libtiff != NULL)  return;
94         /* For solaris */
95         libtiff = PIL_dynlib_open("/usr/openwin/lib/libtiff.so");
96         if (libtiff != NULL)  return;
97         
98 #endif
99
100         filename = getenv("BF_TIFF_LIB");
101         if (filename) libtiff = PIL_dynlib_open(filename);
102 }
103
104 void *libtiff_findsymbol(char *name)
105 {
106         void *symbol = NULL;
107         assert(libtiff != NULL);
108         symbol = PIL_dynlib_find_symbol(libtiff, name);
109         if (symbol == NULL) {
110                 printf("libtiff_findsymbol: error %s\n",
111                         PIL_dynlib_get_error_as_string(libtiff));
112                 libtiff = NULL;
113                 G.have_libtiff = (0);
114                 return NULL;
115         }
116         return symbol;
117 }
118
119 void libtiff_init(void)
120 {
121         if (libtiff != NULL) {
122                 printf("libtiff_init: Attempted to load libtiff twice!\n");
123                 return;
124         }
125         libtiff_loadlibtiff();
126         G.have_libtiff = ((libtiff != NULL) && (libtiff_load_symbols()));
127 }
128
129 void libtiff_exit(void)
130 {
131         if (libtiff != NULL) {
132                 PIL_dynlib_close(libtiff);
133                 libtiff = NULL;
134         }
135 }
136
137
138 int libtiff_load_symbols(void)
139 {
140         /* Attempt to load TIFFClientOpen */
141         libtiff_TIFFClientOpen = libtiff_findsymbol("TIFFClientOpen");
142         if (libtiff_TIFFClientOpen == NULL) {
143                 return (0);
144         }
145         /* Attempt to load TIFFClose */
146         libtiff_TIFFClose = libtiff_findsymbol("TIFFClose");
147         if (libtiff_TIFFClose == NULL) {
148                 return (0);
149         }
150         /* Attempt to load TIFFGetField */
151         libtiff_TIFFGetField = libtiff_findsymbol("TIFFGetField");
152         if (libtiff_TIFFGetField == NULL) {
153                 return (0);
154         }
155         /* Attempt to load TIFFOpen */
156         libtiff_TIFFOpen = libtiff_findsymbol("TIFFOpen");
157         if (libtiff_TIFFOpen == NULL) {
158                 return (0);
159         }
160         /* Attempt to load TIFFReadRGBAImage */
161         libtiff_TIFFReadRGBAImage = libtiff_findsymbol("TIFFReadRGBAImage");
162         if (libtiff_TIFFReadRGBAImage == NULL) {
163                 return (0);
164         }
165         /* Attempt to load TIFFSetField */
166         libtiff_TIFFSetField = libtiff_findsymbol("TIFFSetField");
167         if (libtiff_TIFFSetField == NULL) {
168                 return (0);
169         }
170         /* Attempt to load TIFFWriteEncodedStrip */
171         libtiff_TIFFWriteEncodedStrip = libtiff_findsymbol("TIFFWriteEncodedStrip");
172         if (libtiff_TIFFWriteEncodedStrip == NULL) {
173                 return (0);
174         }
175         /* Attempt to load _TIFFfree */
176         libtiff__TIFFfree = libtiff_findsymbol("_TIFFfree");
177         if (libtiff__TIFFfree == NULL) {
178                 return (0);
179         }
180         /* Attempt to load _TIFFmalloc */
181         libtiff__TIFFmalloc = libtiff_findsymbol("_TIFFmalloc");
182         if (libtiff__TIFFmalloc == NULL) {
183                 return (0);
184         }
185         return (1);
186 }
187
188         
189 /*******************
190  * SYMBOL POINTERS *
191  *******************/
192
193 TIFF* (*libtiff_TIFFClientOpen)(const char*, const char*, thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc) = NULL;
194 void (*libtiff_TIFFClose)(TIFF*) = NULL;
195 int (*libtiff_TIFFGetField)(TIFF*, ttag_t, ...) = NULL;
196 TIFF* (*libtiff_TIFFOpen)(const char*, const char*) = NULL;
197 int (*libtiff_TIFFReadRGBAImage)(TIFF*, uint32, uint32, uint32*, int) = NULL;
198 int (*libtiff_TIFFSetField)(TIFF*, ttag_t, ...) = NULL;
199 tsize_t (*libtiff_TIFFWriteEncodedStrip)(TIFF*, tstrip_t, tdata_t, tsize_t) = NULL;
200 void (*libtiff__TIFFfree)(tdata_t) = NULL;
201 tdata_t (*libtiff__TIFFmalloc)(tsize_t) = NULL;