This commit does very little for the number of files touched.
[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
81         /* Try to find libtiff in a couple of standard places */
82         libtiff = PIL_dynlib_open("libtiff.so");
83         if (libtiff != NULL)  return;
84         libtiff = PIL_dynlib_open("libtiff.dll");
85         if (libtiff != NULL)  return;
86         libtiff = PIL_dynlib_open("/usr/lib/libtiff.so");
87         if (libtiff != NULL)  return;
88         /* OSX has version specific library */
89         libtiff = PIL_dynlib_open("/usr/lib/libtiff.so.3");
90         if (libtiff != NULL)  return;
91         libtiff = PIL_dynlib_open("/usr/local/lib/libtiff.so");
92         if (libtiff != NULL)  return;
93         /* For solaris */
94         libtiff = PIL_dynlib_open("/usr/openwin/lib/libtiff.so");
95         if (libtiff != NULL)  return;
96
97 #endif
98
99         filename = getenv("BF_TIFF_LIB");
100         if (filename) libtiff = PIL_dynlib_open(filename);
101 }
102
103 void *libtiff_findsymbol(char *name)
104 {
105         void *symbol = NULL;
106         assert(libtiff != NULL);
107         symbol = PIL_dynlib_find_symbol(libtiff, name);
108         if (symbol == NULL) {
109                 printf("libtiff_findsymbol: error %s\n",
110                         PIL_dynlib_get_error_as_string(libtiff));
111                 libtiff = NULL;
112                 G.have_libtiff = (0);
113                 return NULL;
114         }
115         return symbol;
116 }
117
118 void libtiff_init(void)
119 {
120         if (libtiff != NULL) {
121                 printf("libtiff_init: Attempted to load libtiff twice!\n");
122                 return;
123         }
124         libtiff_loadlibtiff();
125         G.have_libtiff = ((libtiff != NULL) && (libtiff_load_symbols()));
126 }
127
128 void libtiff_exit(void)
129 {
130         if (libtiff != NULL) {
131                 PIL_dynlib_close(libtiff);
132                 libtiff = NULL;
133         }
134 }
135
136
137 int libtiff_load_symbols(void)
138 {
139         /* Attempt to load TIFFClientOpen */
140         libtiff_TIFFClientOpen = libtiff_findsymbol("TIFFClientOpen");
141         if (libtiff_TIFFClientOpen == NULL) {
142                 return (0);
143         }
144         /* Attempt to load TIFFClose */
145         libtiff_TIFFClose = libtiff_findsymbol("TIFFClose");
146         if (libtiff_TIFFClose == NULL) {
147                 return (0);
148         }
149         /* Attempt to load TIFFGetField */
150         libtiff_TIFFGetField = libtiff_findsymbol("TIFFGetField");
151         if (libtiff_TIFFGetField == NULL) {
152                 return (0);
153         }
154         /* Attempt to load TIFFOpen */
155         libtiff_TIFFOpen = libtiff_findsymbol("TIFFOpen");
156         if (libtiff_TIFFOpen == NULL) {
157                 return (0);
158         }
159         /* Attempt to load TIFFReadRGBAImage */
160         libtiff_TIFFReadRGBAImage = libtiff_findsymbol("TIFFReadRGBAImage");
161         if (libtiff_TIFFReadRGBAImage == NULL) {
162                 return (0);
163         }
164         /* Attempt to load TIFFSetField */
165         libtiff_TIFFSetField = libtiff_findsymbol("TIFFSetField");
166         if (libtiff_TIFFSetField == NULL) {
167                 return (0);
168         }
169         /* Attempt to load TIFFWriteEncodedStrip */
170         libtiff_TIFFWriteEncodedStrip = libtiff_findsymbol("TIFFWriteEncodedStrip");
171         if (libtiff_TIFFWriteEncodedStrip == NULL) {
172                 return (0);
173         }
174         /* Attempt to load _TIFFfree */
175         libtiff__TIFFfree = libtiff_findsymbol("_TIFFfree");
176         if (libtiff__TIFFfree == NULL) {
177                 return (0);
178         }
179         /* Attempt to load _TIFFmalloc */
180         libtiff__TIFFmalloc = libtiff_findsymbol("_TIFFmalloc");
181         if (libtiff__TIFFmalloc == NULL) {
182                 return (0);
183         }
184         return (1);
185 }
186
187         
188 /*******************
189  * SYMBOL POINTERS *
190  *******************/
191
192 TIFF* (*libtiff_TIFFClientOpen)(const char*, const char*, thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc) = NULL;
193 void (*libtiff_TIFFClose)(TIFF*) = NULL;
194 int (*libtiff_TIFFGetField)(TIFF*, ttag_t, ...) = NULL;
195 TIFF* (*libtiff_TIFFOpen)(const char*, const char*) = NULL;
196 int (*libtiff_TIFFReadRGBAImage)(TIFF*, uint32, uint32, uint32*, int) = NULL;
197 int (*libtiff_TIFFSetField)(TIFF*, ttag_t, ...) = NULL;
198 tsize_t (*libtiff_TIFFWriteEncodedStrip)(TIFF*, tstrip_t, tdata_t, tsize_t) = NULL;
199 void (*libtiff__TIFFfree)(tdata_t) = NULL;
200 tdata_t (*libtiff__TIFFmalloc)(tsize_t) = NULL;