1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 // By downloading, copying, installing or using the software you agree to this license.
6 // If you do not agree to this license, do not download, install,
7 // copy or use the software.
8 //
9 //
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
21 //
22 // * Redistribution's in binary form must reproduce the above copyright notice,
23 // this list of conditions and the following disclaimer in the documentation
24 // and/or other materials provided with the distribution.
25 //
26 // * The name of Intel Corporation may not be used to endorse or promote products
27 // derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #include "_highgui.h"
43
44 #include "grfmt_base.h"
45 #include "bitstrm.h"
46
47
GrFmtReader(const char * filename)48 GrFmtReader::GrFmtReader( const char* filename )
49 {
50 strncpy( m_filename, filename, sizeof(m_filename) - 1 );
51 m_filename[sizeof(m_filename)-1] = '\0';
52 m_width = m_height = 0;
53 m_iscolor = false;
54 m_bit_depth = 8;
55 m_native_depth = false;
56 m_isfloat = false;
57 }
58
59
~GrFmtReader()60 GrFmtReader::~GrFmtReader()
61 {
62 Close();
63 }
64
65
Close()66 void GrFmtReader::Close()
67 {
68 m_width = m_height = 0;
69 m_iscolor = false;
70 }
71
72
GrFmtWriter(const char * filename)73 GrFmtWriter::GrFmtWriter( const char* filename )
74 {
75 strncpy( m_filename, filename, sizeof(m_filename) - 1 );
76 m_filename[sizeof(m_filename)-1] = '\0';
77 }
78
79
IsFormatSupported(int depth)80 bool GrFmtWriter::IsFormatSupported( int depth )
81 {
82 return depth == IPL_DEPTH_8U;
83 }
84
85
GrFmtFilterFactory()86 GrFmtFilterFactory::GrFmtFilterFactory()
87 {
88 m_description = m_signature = 0;
89 m_sign_len = 0;
90 }
91
92
CheckFile(const char * filename)93 bool GrFmtFilterFactory::CheckFile( const char* filename )
94 {
95 FILE* f = 0;
96 char signature[4096];
97 int sign_len = 0;
98 int cur_sign_len = GetSignatureLength();
99
100 if( !filename ) return false;
101
102 assert( cur_sign_len <= (int)sizeof( signature ) );
103 f = fopen( filename, "rb" );
104
105 if( f )
106 {
107 sign_len = (int)fread( signature, 1, cur_sign_len, f );
108 fclose( f );
109
110 if( cur_sign_len <= sign_len && CheckSignature( signature ) )
111 return true;
112 }
113
114 return false;
115 }
116
117
CheckSignature(const char * signature)118 bool GrFmtFilterFactory::CheckSignature( const char* signature )
119 {
120 return m_sign_len > 0 && signature != 0 &&
121 memcmp( signature, m_signature, m_sign_len ) == 0;
122 }
123
124
GetExtensionLength(const char * buffer)125 static int GetExtensionLength( const char* buffer )
126 {
127 int len = 0;
128
129 if( buffer )
130 {
131 const char* ext = strchr( buffer, '.');
132 if( ext++ )
133 while( isalnum(ext[len]) && len < _MAX_PATH )
134 len++;
135 }
136
137 return len;
138 }
139
140
CheckExtension(const char * format)141 bool GrFmtFilterFactory::CheckExtension( const char* format )
142 {
143 const char* descr = 0;
144 int len = 0;
145
146 if( !format || !m_description )
147 return false;
148
149 // find the right-most extension of the passed format string
150 for(;;)
151 {
152 const char* ext = strchr( format + 1, '.' );
153 if( !ext ) break;
154 format = ext;
155 }
156
157 len = GetExtensionLength( format );
158
159 if( format[0] != '.' || len == 0 )
160 return false;
161
162 descr = strchr( m_description, '(' );
163
164 while( descr )
165 {
166 descr = strchr( descr + 1, '.' );
167 int i, len2 = GetExtensionLength( descr );
168
169 if( len2 == 0 )
170 break;
171
172 if( len2 == len )
173 {
174 for( i = 0; i < len; i++ )
175 {
176 int c1 = tolower(format[i+1]);
177 int c2 = tolower(descr[i+1]);
178
179 if( c1 != c2 )
180 break;
181 }
182 if( i == len )
183 return true;
184 }
185 }
186
187 return false;
188 }
189
190
191
192 ///////////////////// GrFmtFilterList //////////////////////////
193
GrFmtFactoriesList()194 GrFmtFactoriesList::GrFmtFactoriesList()
195 {
196 m_factories = 0;
197 RemoveAll();
198 }
199
200
~GrFmtFactoriesList()201 GrFmtFactoriesList::~GrFmtFactoriesList()
202 {
203 RemoveAll();
204 }
205
206
RemoveAll()207 void GrFmtFactoriesList::RemoveAll()
208 {
209 if( m_factories )
210 {
211 for( int i = 0; i < m_curFactories; i++ ) delete m_factories[i];
212 delete[] m_factories;
213 }
214 m_factories = 0;
215 m_maxFactories = m_curFactories = 0;
216 }
217
218
AddFactory(GrFmtFilterFactory * factory)219 bool GrFmtFactoriesList::AddFactory( GrFmtFilterFactory* factory )
220 {
221 assert( factory != 0 );
222 if( m_curFactories == m_maxFactories )
223 {
224 // reallocate the factorys pointers storage
225 int newMaxFactories = 2*m_maxFactories;
226 if( newMaxFactories < 16 ) newMaxFactories = 16;
227
228 GrFmtFilterFactory** newFactories = new GrFmtFilterFactory*[newMaxFactories];
229
230 for( int i = 0; i < m_curFactories; i++ ) newFactories[i] = m_factories[i];
231
232 delete[] m_factories;
233 m_factories = newFactories;
234 m_maxFactories = newMaxFactories;
235 }
236
237 m_factories[m_curFactories++] = factory;
238 return true;
239 }
240
241
GetFirstFactoryPos()242 ListPosition GrFmtFactoriesList::GetFirstFactoryPos()
243 {
244 return (ListPosition)m_factories;
245 }
246
247
GetNextFactory(ListPosition & pos)248 GrFmtFilterFactory* GrFmtFactoriesList::GetNextFactory( ListPosition& pos )
249 {
250 GrFmtFilterFactory* factory = 0;
251 GrFmtFilterFactory** temp = (GrFmtFilterFactory**)pos;
252
253 assert( temp == 0 || (m_factories <= temp && temp < m_factories + m_curFactories));
254 if( temp )
255 {
256 factory = *temp++;
257 pos = (ListPosition)(temp < m_factories + m_curFactories ? temp : 0);
258 }
259 return factory;
260 }
261
262
FindReader(const char * filename)263 GrFmtReader* GrFmtFactoriesList::FindReader( const char* filename )
264 {
265 if( !filename ) return 0;
266
267 GrFmtReader* reader = 0;
268 ListPosition pos = GetFirstFactoryPos();
269
270 while( pos )
271 {
272 GrFmtFilterFactory* tempFactory = GetNextFactory( pos );
273 if( tempFactory->CheckFile( filename ) )
274 {
275 reader = tempFactory->NewReader( filename );
276 break;
277 }
278 }
279
280 return reader;
281 }
282
283
FindWriter(const char * filename)284 GrFmtWriter* GrFmtFactoriesList::FindWriter( const char* filename )
285 {
286 GrFmtWriter* writer = 0;
287 ListPosition pos = GetFirstFactoryPos();
288
289 if( !filename ) return 0;
290
291 while( pos )
292 {
293 GrFmtFilterFactory* tempFactory = GetNextFactory(pos);
294 if( tempFactory->CheckExtension( filename ))
295 {
296 writer = tempFactory->NewWriter( filename );
297 break;
298 }
299 }
300
301 return writer;
302 }
303
304 /* End of file. */
305
306