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
48GrFmtReader::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
60GrFmtReader::~GrFmtReader()
61{
62    Close();
63}
64
65
66void GrFmtReader::Close()
67{
68    m_width = m_height = 0;
69    m_iscolor = false;
70}
71
72
73GrFmtWriter::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
80bool  GrFmtWriter::IsFormatSupported( int depth )
81{
82    return depth == IPL_DEPTH_8U;
83}
84
85
86GrFmtFilterFactory::GrFmtFilterFactory()
87{
88    m_description = m_signature = 0;
89    m_sign_len = 0;
90}
91
92
93bool  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
118bool 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
125static 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
141bool 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
194GrFmtFactoriesList::GrFmtFactoriesList()
195{
196    m_factories = 0;
197    RemoveAll();
198}
199
200
201GrFmtFactoriesList::~GrFmtFactoriesList()
202{
203    RemoveAll();
204}
205
206
207void  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
219bool  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
242ListPosition  GrFmtFactoriesList::GetFirstFactoryPos()
243{
244    return (ListPosition)m_factories;
245}
246
247
248GrFmtFilterFactory* 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
263GrFmtReader* 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
284GrFmtWriter* 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