1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_extensions.hxx"
26 #include <cstdarg>
27 #include <math.h>
28 #include <osl/file.h>
29 #include <tools/stream.hxx>
30 #include <sane.hxx>
31 #include <dlfcn.h>
32 #include <stdio.h>
33 #include <unistd.h>
34 #include <sys/time.h>
35 #include <sys/types.h>
36 #include <sal/config.h>
37
38 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
39 #include <stdarg.h>
40 #define dump_state( a, b, c, d ) fprintf( stderr, a, b, c, d );
41 #else
42 #define dump_state( a, b, c, d ) ;
43 #endif
dbg_msg(const char * pString,...)44 inline void dbg_msg( const char* pString, ... )
45 {
46 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
47 va_list ap;
48 va_start( ap, pString );
49 vfprintf( stderr, pString, ap );
50 va_end( ap );
51 #else
52 (void)pString;
53 #endif
54 }
55
56 #define FAIL_SHUTDOWN_STATE( x, y, z ) \
57 if( x != SANE_STATUS_GOOD ) \
58 { \
59 dump_state( "%s returned error %d (%s)\n", \
60 y, x, p_strstatus( x ) ); \
61 DeInit(); \
62 return z; \
63 }
64
65 #define FAIL_STATE( x, y, z ) \
66 if( x != SANE_STATUS_GOOD ) \
67 { \
68 dump_state( "%s returned error %d (%s)\n", \
69 y, x, p_strstatus( x ) ); \
70 return z; \
71 }
72
73 #define DUMP_STATE( x, y ) \
74 if( x != SANE_STATUS_GOOD ) \
75 { \
76 dump_state( "%s returned error %d (%s)\n", \
77 y, x, p_strstatus( x ) ); \
78 }
79
80 #define CHECK_STATE( x, y ) \
81 if( x != SANE_STATUS_GOOD ) \
82 { \
83 dump_state( "%s returned error %d (%s)\n", \
84 y, x, p_strstatus( x ) ); \
85 } \
86 else
87
88 int Sane::nRefCount = 0;
89 oslModule Sane::pSaneLib = 0;
90 SANE_Int Sane::nVersion = 0;
91 SANE_Device** Sane::ppDevices = 0;
92 int Sane::nDevices = 0;
93
94 SANE_Status (*Sane::p_init)( SANE_Int*,
95 SANE_Auth_Callback ) = 0;
96 void (*Sane::p_exit)() = 0;
97 SANE_Status (*Sane::p_get_devices)( const SANE_Device***,
98 SANE_Bool ) = 0;
99 SANE_Status (*Sane::p_open)( SANE_String_Const, SANE_Handle ) = 0;
100 void (*Sane::p_close)( SANE_Handle ) = 0;
101 const SANE_Option_Descriptor* (*Sane::p_get_option_descriptor)(
102 SANE_Handle, SANE_Int ) = 0;
103 SANE_Status (*Sane::p_control_option)( SANE_Handle, SANE_Int,
104 SANE_Action, void*,
105 SANE_Int* ) = 0;
106 SANE_Status (*Sane::p_get_parameters)( SANE_Handle,
107 SANE_Parameters* ) = 0;
108 SANE_Status (*Sane::p_start)( SANE_Handle ) = 0;
109 SANE_Status (*Sane::p_read)( SANE_Handle, SANE_Byte*, SANE_Int,
110 SANE_Int* ) = 0;
111 void (*Sane::p_cancel)( SANE_Handle ) = 0;
112 SANE_Status (*Sane::p_set_io_mode)( SANE_Handle, SANE_Bool ) = 0;
113 SANE_Status (*Sane::p_get_select_fd)( SANE_Handle, SANE_Int* ) = 0;
114 SANE_String_Const (*Sane::p_strstatus)( SANE_Status ) = 0;
115
116 static sal_Bool bSaneSymbolLoadFailed = sal_False;
117
LoadSymbol(const char * pSymbolname)118 inline oslGenericFunction Sane::LoadSymbol( const char* pSymbolname )
119 {
120 oslGenericFunction pFunction = osl_getAsciiFunctionSymbol( pSaneLib, pSymbolname );
121 if( ! pFunction )
122 {
123 fprintf( stderr, "Could not load symbol %s\n",
124 pSymbolname );
125 bSaneSymbolLoadFailed = sal_True;
126 }
127 return pFunction;
128 }
129
ControlOption(int nOption,SANE_Action nAction,void * pData)130 SANE_Status Sane::ControlOption( int nOption, SANE_Action nAction,
131 void* pData )
132 {
133 SANE_Status nStatus = SANE_STATUS_GOOD;
134 SANE_Int nInfo = 0;
135
136 nStatus = p_control_option( maHandle, (SANE_Int)nOption,
137 nAction, pData, &nInfo );
138 DUMP_STATE( nStatus, "sane_control_option" );
139 #if OSL_DEBUG_LEVEL > 1
140 if( nStatus != SANE_STATUS_GOOD )
141 {
142 const char* pAction = "Unknown";
143 switch( nAction )
144 {
145 case SANE_ACTION_GET_VALUE:
146 pAction = "SANE_ACTION_GET_VALUE";break;
147 case SANE_ACTION_SET_VALUE:
148 pAction = "SANE_ACTION_SET_VALUE";break;
149 case SANE_ACTION_SET_AUTO:
150 pAction = "SANE_ACTION_SET_AUTO";break;
151 }
152 dbg_msg( "Option: \"%s\" action: %s\n",
153 ByteString( GetOptionName( nOption ), gsl_getSystemTextEncoding() ).GetBuffer(),
154 pAction );
155 }
156 #endif
157 // if( nInfo & ( SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS ) )
158 if( nInfo & SANE_INFO_RELOAD_OPTIONS )
159 ReloadOptions();
160 return nStatus;
161 }
162
Sane()163 Sane::Sane() :
164 mppOptions( 0 ),
165 mnOptions( 0 ),
166 mnDevice( -1 ),
167 maHandle( 0 )
168 {
169 if( ! nRefCount || ! pSaneLib )
170 Init();
171 nRefCount++;
172 };
173
~Sane()174 Sane::~Sane()
175 {
176 if( IsOpen() )
177 Close();
178 nRefCount--;
179 if( ! nRefCount && pSaneLib )
180 DeInit();
181 }
182
Init()183 void Sane::Init()
184 {
185 ::rtl::OUString sSaneLibName( ::rtl::OUString::createFromAscii( "libsane" SAL_DLLEXTENSION ) );
186 pSaneLib = osl_loadModule( sSaneLibName.pData, SAL_LOADMODULE_LAZY );
187 if( ! pSaneLib )
188 {
189 sSaneLibName = ::rtl::OUString::createFromAscii( "libsane" SAL_DLLEXTENSION ".1" );
190 pSaneLib = osl_loadModule( sSaneLibName.pData, SAL_LOADMODULE_LAZY );
191 }
192 // try reasonable places that might not be in the library search path
193 if( ! pSaneLib )
194 {
195 ::rtl::OUString sSaneLibSystemPath( ::rtl::OUString::createFromAscii( "/usr/local/lib/libsane" SAL_DLLEXTENSION ) );
196 osl_getFileURLFromSystemPath( sSaneLibSystemPath.pData, &sSaneLibName.pData );
197 pSaneLib = osl_loadModule( sSaneLibName.pData, SAL_LOADMODULE_LAZY );
198 }
199
200 if( pSaneLib )
201 {
202 bSaneSymbolLoadFailed = sal_False;
203 p_init = (SANE_Status(*)(SANE_Int*, SANE_Auth_Callback ))
204 LoadSymbol( "sane_init" );
205 p_exit = (void(*)())
206 LoadSymbol( "sane_exit" );
207 p_get_devices = (SANE_Status(*)(const SANE_Device***,
208 SANE_Bool ))
209 LoadSymbol( "sane_get_devices" );
210 p_open = (SANE_Status(*)(SANE_String_Const, SANE_Handle ))
211 LoadSymbol( "sane_open" );
212 p_close = (void(*)(SANE_Handle))
213 LoadSymbol( "sane_close" );
214 p_get_option_descriptor = (const SANE_Option_Descriptor*(*)(SANE_Handle,
215 SANE_Int))
216 LoadSymbol( "sane_get_option_descriptor" );
217 p_control_option = (SANE_Status(*)(SANE_Handle, SANE_Int,
218 SANE_Action, void*, SANE_Int*))
219 LoadSymbol( "sane_control_option" );
220 p_get_parameters = (SANE_Status(*)(SANE_Handle,SANE_Parameters*))
221 LoadSymbol( "sane_get_parameters" );
222 p_start = (SANE_Status(*)(SANE_Handle))
223 LoadSymbol( "sane_start" );
224 p_read = (SANE_Status(*)(SANE_Handle, SANE_Byte*,
225 SANE_Int, SANE_Int* ))
226 LoadSymbol( "sane_read" );
227 p_cancel = (void(*)(SANE_Handle))
228 LoadSymbol( "sane_cancel" );
229 p_set_io_mode = (SANE_Status(*)(SANE_Handle, SANE_Bool))
230 LoadSymbol( "sane_set_io_mode" );
231 p_get_select_fd = (SANE_Status(*)(SANE_Handle, SANE_Int*))
232 LoadSymbol( "sane_get_select_fd" );
233 p_strstatus = (SANE_String_Const(*)(SANE_Status))
234 LoadSymbol( "sane_strstatus" );
235 if( bSaneSymbolLoadFailed )
236 DeInit();
237 else
238 {
239 SANE_Status nStatus = p_init( &nVersion, 0 );
240 FAIL_SHUTDOWN_STATE( nStatus, "sane_init", );
241 nStatus = p_get_devices( (const SANE_Device***)&ppDevices,
242 SANE_FALSE );
243 FAIL_SHUTDOWN_STATE( nStatus, "sane_get_devices", );
244 for( nDevices = 0 ; ppDevices[ nDevices ]; nDevices++ ) ;
245 }
246 }
247 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
248 else
249 fprintf( stderr, "libsane%s could not be opened: %s\n", SAL_DLLEXTENSION,
250 dlerror() );
251 #endif
252 }
253
DeInit()254 void Sane::DeInit()
255 {
256 if( pSaneLib )
257 {
258 p_exit();
259 osl_unloadModule( pSaneLib );
260 pSaneLib = 0;
261 }
262 }
263
ReloadDevices()264 void Sane::ReloadDevices()
265 {
266 if( IsOpen() )
267 Close();
268 DeInit();
269 Init();
270 }
271
ReloadOptions()272 void Sane::ReloadOptions()
273 {
274 if( ! IsOpen() )
275 return;
276
277 SANE_Option_Descriptor* pZero = (SANE_Option_Descriptor*)
278 p_get_option_descriptor( maHandle, 0 );
279 SANE_Word pOptions[2];
280 SANE_Status nStatus = p_control_option( maHandle, 0, SANE_ACTION_GET_VALUE,
281 (void*)pOptions, NULL );
282 if( nStatus != SANE_STATUS_GOOD )
283 fprintf( stderr, "Error: sane driver returned %s while reading number of options !\n", p_strstatus( nStatus ) );
284
285 mnOptions = pOptions[ 0 ];
286 if( (size_t)pZero->size > sizeof( SANE_Word ) )
287 fprintf( stderr, "driver returned numer of options with larger size tha SANE_Word !!!\n" );
288 if( mppOptions )
289 delete [] mppOptions;
290 mppOptions = (const SANE_Option_Descriptor**)new SANE_Option_Descriptor*[ mnOptions ];
291 mppOptions[ 0 ] = (SANE_Option_Descriptor*)pZero;
292 for( int i = 1; i < mnOptions; i++ )
293 mppOptions[ i ] = (SANE_Option_Descriptor*)
294 p_get_option_descriptor( maHandle, i );
295
296 CheckConsistency( NULL, sal_True );
297
298 maReloadOptionsLink.Call( this );
299 }
300
Open(const char * name)301 sal_Bool Sane::Open( const char* name )
302 {
303 int i;
304
305 SANE_Status nStatus = p_open( (SANE_String_Const)name, &maHandle );
306 FAIL_STATE( nStatus, "sane_open", sal_False );
307
308 ReloadOptions();
309
310 if( mnDevice == -1 )
311 {
312 ByteString aDevice( name );
313 for( i = 0; i < nDevices; i++ )
314 {
315 if( aDevice.Equals( ppDevices[i]->name ) )
316 {
317 mnDevice = i;
318 break;
319 }
320 }
321 }
322
323 return sal_True;
324 }
325
Open(int n)326 sal_Bool Sane::Open( int n )
327 {
328 if( n >= 0 && n < nDevices )
329 {
330 mnDevice = n;
331 return Open( (char*)ppDevices[n]->name );
332 }
333 return sal_False;
334 }
335
Close()336 void Sane::Close()
337 {
338 if( maHandle )
339 {
340 p_close( maHandle );
341 delete [] mppOptions;
342 mppOptions = 0;
343 maHandle = 0;
344 mnDevice = -1;
345 }
346 }
347
GetOptionByName(const char * rName)348 int Sane::GetOptionByName( const char* rName )
349 {
350 int i;
351 ByteString aOption( rName );
352 for( i = 0; i < mnOptions; i++ )
353 {
354 if( mppOptions[i]->name && aOption.Equals( mppOptions[i]->name ) )
355 return i;
356 }
357 return -1;
358 }
359
GetOptionValue(int n,sal_Bool & rRet)360 sal_Bool Sane::GetOptionValue( int n, sal_Bool& rRet )
361 {
362 if( ! maHandle || mppOptions[n]->type != SANE_TYPE_BOOL )
363 return sal_False;
364 SANE_Word nRet;
365 SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, &nRet );
366 if( nStatus != SANE_STATUS_GOOD )
367 return sal_False;
368
369 rRet = nRet;
370 return sal_True;
371 }
372
GetOptionValue(int n,ByteString & rRet)373 sal_Bool Sane::GetOptionValue( int n, ByteString& rRet )
374 {
375 sal_Bool bSuccess = sal_False;
376 if( ! maHandle || mppOptions[n]->type != SANE_TYPE_STRING )
377 return sal_False;
378 char* pRet = new char[mppOptions[n]->size+1];
379 SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pRet );
380 if( nStatus == SANE_STATUS_GOOD )
381 {
382 bSuccess = sal_True;
383 rRet = pRet;
384 }
385 delete [] pRet;
386 return bSuccess;
387 }
388
GetOptionValue(int n,double & rRet,int nElement)389 sal_Bool Sane::GetOptionValue( int n, double& rRet, int nElement )
390 {
391 sal_Bool bSuccess = sal_False;
392
393 if( ! maHandle || ( mppOptions[n]->type != SANE_TYPE_INT &&
394 mppOptions[n]->type != SANE_TYPE_FIXED ) )
395 return sal_False;
396
397 SANE_Word* pRet = new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)];
398 SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pRet );
399 if( nStatus == SANE_STATUS_GOOD )
400 {
401 bSuccess = sal_True;
402 if( mppOptions[n]->type == SANE_TYPE_INT )
403 rRet = (double)pRet[ nElement ];
404 else
405 rRet = SANE_UNFIX( pRet[nElement] );
406 }
407 delete [] pRet;
408 return bSuccess;
409 }
410
GetOptionValue(int n,double * pSet)411 sal_Bool Sane::GetOptionValue( int n, double* pSet )
412 {
413 if( ! maHandle || ! ( mppOptions[n]->type == SANE_TYPE_FIXED ||
414 mppOptions[n]->type == SANE_TYPE_INT ) )
415 return sal_False;
416
417 SANE_Word* pFixedSet = new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)];
418 SANE_Status nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pFixedSet );
419 if( nStatus != SANE_STATUS_GOOD )
420 {
421 delete [] pFixedSet;
422 return sal_False;
423 }
424 for( size_t i = 0; i <mppOptions[n]->size/sizeof(SANE_Word); i++ )
425 {
426 if( mppOptions[n]->type == SANE_TYPE_FIXED )
427 pSet[i] = SANE_UNFIX( pFixedSet[i] );
428 else
429 pSet[i] = (double) pFixedSet[i];
430 }
431 delete [] pFixedSet;
432 return sal_True;
433 }
434
SetOptionValue(int n,sal_Bool bSet)435 sal_Bool Sane::SetOptionValue( int n, sal_Bool bSet )
436 {
437 if( ! maHandle || mppOptions[n]->type != SANE_TYPE_BOOL )
438 return sal_False;
439 SANE_Word nRet = bSet ? SANE_TRUE : SANE_FALSE;
440 SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, &nRet );
441 if( nStatus != SANE_STATUS_GOOD )
442 return sal_False;
443 return sal_True;
444 }
445
SetOptionValue(int n,const String & rSet)446 sal_Bool Sane::SetOptionValue( int n, const String& rSet )
447 {
448 if( ! maHandle || mppOptions[n]->type != SANE_TYPE_STRING )
449 return sal_False;
450 ByteString aSet( rSet, gsl_getSystemTextEncoding() );
451 SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, (void*)aSet.GetBuffer() );
452 if( nStatus != SANE_STATUS_GOOD )
453 return sal_False;
454 return sal_True;
455 }
456
SetOptionValue(int n,double fSet,int nElement)457 sal_Bool Sane::SetOptionValue( int n, double fSet, int nElement )
458 {
459 sal_Bool bSuccess = sal_False;
460
461 if( ! maHandle || ( mppOptions[n]->type != SANE_TYPE_INT &&
462 mppOptions[n]->type != SANE_TYPE_FIXED ) )
463 return sal_False;
464
465 SANE_Status nStatus;
466 if( mppOptions[n]->size/sizeof(SANE_Word) > 1 )
467 {
468 SANE_Word* pSet = new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)];
469 nStatus = ControlOption( n, SANE_ACTION_GET_VALUE, pSet );
470 if( nStatus == SANE_STATUS_GOOD )
471 {
472 pSet[nElement] = mppOptions[n]->type == SANE_TYPE_INT ?
473 (SANE_Word)fSet : SANE_FIX( fSet );
474 nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, pSet );
475 }
476 delete [] pSet;
477 }
478 else
479 {
480 SANE_Word nSetTo =
481 mppOptions[n]->type == SANE_TYPE_INT ?
482 (SANE_Word)fSet : SANE_FIX( fSet );
483
484 nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, &nSetTo );
485 if( nStatus == SANE_STATUS_GOOD )
486 bSuccess = sal_True;
487 }
488 return bSuccess;
489 }
490
SetOptionValue(int n,double * pSet)491 sal_Bool Sane::SetOptionValue( int n, double* pSet )
492 {
493 if( ! maHandle || ( mppOptions[n]->type != SANE_TYPE_INT &&
494 mppOptions[n]->type != SANE_TYPE_FIXED ) )
495 return sal_False;
496 SANE_Word* pFixedSet = new SANE_Word[mppOptions[n]->size/sizeof(SANE_Word)];
497 for( size_t i = 0; i < mppOptions[n]->size/sizeof(SANE_Word); i++ )
498 {
499 if( mppOptions[n]->type == SANE_TYPE_FIXED )
500 pFixedSet[i] = SANE_FIX( pSet[i] );
501 else
502 pFixedSet[i] = (SANE_Word)pSet[i];
503 }
504 SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, pFixedSet );
505 delete [] pFixedSet;
506 if( nStatus != SANE_STATUS_GOOD )
507 return sal_False;
508 return sal_True;
509 }
510
511 enum FrameStyleType {
512 FrameStyle_BW, FrameStyle_Gray, FrameStyle_RGB, FrameStyle_Separated
513 };
514
515 #define BYTE_BUFFER_SIZE 32768
516
_ReadValue(FILE * fp,int depth)517 static inline sal_uInt8 _ReadValue( FILE* fp, int depth )
518 {
519 if( depth == 16 )
520 {
521 sal_uInt16 nWord;
522 // data always come in native byte order !
523 // 16 bits is not really supported by backends as of now
524 // e.g. UMAX Astra 1200S delivers 16 bit but in BIGENDIAN
525 // against SANE documentation (xscanimage gets the same result
526 // as we do
527 fread( &nWord, 1, 2, fp );
528 return (sal_uInt8)( nWord / 256 );
529 }
530 sal_uInt8 nByte;
531 fread( &nByte, 1, 1, fp );
532 return nByte;
533 }
534
CheckConsistency(const char * pMes,sal_Bool bInit)535 sal_Bool Sane::CheckConsistency( const char* pMes, sal_Bool bInit )
536 {
537 static SANE_Option_Descriptor** pDescArray = NULL;
538 static SANE_Option_Descriptor* pZero = NULL;
539
540 if( bInit )
541 {
542 pDescArray = (SANE_Option_Descriptor**)mppOptions;
543 if( mppOptions )
544 pZero = (SANE_Option_Descriptor*)mppOptions[0];
545 return sal_True;
546 }
547
548 sal_Bool bConsistent = sal_True;
549
550 if( pDescArray != mppOptions )
551 bConsistent = sal_False;
552 if( pZero != mppOptions[0] )
553 bConsistent = sal_False;
554
555 if( ! bConsistent )
556 dbg_msg( "Sane is not consistent. (%s)\n", pMes );
557
558 return bConsistent;
559 }
560
Start(BitmapTransporter & rBitmap)561 sal_Bool Sane::Start( BitmapTransporter& rBitmap )
562 {
563 int nStream = 0, nLine = 0, i = 0;
564 SANE_Parameters aParams;
565 FrameStyleType eType = FrameStyle_Gray;
566 sal_Bool bSuccess = sal_True;
567 sal_Bool bWidthSet = sal_False;
568
569 if( ! maHandle )
570 return sal_False;
571
572 int nWidthMM = 0;
573 int nHeightMM = 0;
574 double fTLx, fTLy, fBRx, fBRy, fResl = 0.0;
575 int nOption;
576 if( ( nOption = GetOptionByName( "tl-x" ) ) != -1 &&
577 GetOptionValue( nOption, fTLx, 0 ) &&
578 GetOptionUnit( nOption ) == SANE_UNIT_MM )
579 {
580 if( ( nOption = GetOptionByName( "br-x" ) ) != -1 &&
581 GetOptionValue( nOption, fBRx, 0 ) &&
582 GetOptionUnit( nOption ) == SANE_UNIT_MM )
583 {
584 nWidthMM = (int)fabs(fBRx - fTLx);
585 }
586 }
587 if( ( nOption = GetOptionByName( "tl-y" ) ) != -1 &&
588 GetOptionValue( nOption, fTLy, 0 ) &&
589 GetOptionUnit( nOption ) == SANE_UNIT_MM )
590 {
591 if( ( nOption = GetOptionByName( "br-y" ) ) != -1 &&
592 GetOptionValue( nOption, fBRy, 0 ) &&
593 GetOptionUnit( nOption ) == SANE_UNIT_MM )
594 {
595 nHeightMM = (int)fabs(fBRy - fTLy);
596 }
597 }
598 if( ( nOption = GetOptionByName( "resolution" ) ) != -1 )
599 GetOptionValue( nOption, fResl );
600
601 sal_uInt8* pBuffer = NULL;
602
603 SANE_Status nStatus = SANE_STATUS_GOOD;
604
605 rBitmap.lock();
606 SvMemoryStream& aConverter = rBitmap.getStream();
607 aConverter.Seek( 0 );
608 aConverter.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
609
610 // write bitmap stream header
611 aConverter << 'B' << 'M';
612 aConverter << (sal_uInt32) 0;
613 aConverter << (sal_uInt32) 0;
614 aConverter << (sal_uInt32) 60;
615
616 // write BITMAPINFOHEADER
617 aConverter << (sal_uInt32)40;
618 aConverter << (sal_uInt32)0; // fill in width later
619 aConverter << (sal_uInt32)0; // fill in height later
620 aConverter << (sal_uInt16)1;
621 // create header for 24 bits
622 // correct later if necessary
623 aConverter << (sal_uInt16)24;
624 aConverter << (sal_uInt32)0;
625 aConverter << (sal_uInt32)0;
626 aConverter << (sal_uInt32)0;
627 aConverter << (sal_uInt32)0;
628 aConverter << (sal_uInt32)0;
629 aConverter << (sal_uInt32)0;
630
631 for( nStream=0; nStream < 3 && bSuccess ; nStream++ )
632 {
633 nStatus = p_start( maHandle );
634 DUMP_STATE( nStatus, "sane_start" );
635 CheckConsistency( "sane_start" );
636 if( nStatus == SANE_STATUS_GOOD )
637 {
638 nStatus = p_get_parameters( maHandle, &aParams );
639 DUMP_STATE( nStatus, "sane_get_parameters" );
640 CheckConsistency( "sane_get_parameters" );
641 if (nStatus != SANE_STATUS_GOOD || aParams.bytes_per_line == 0)
642 {
643 bSuccess = sal_False;
644 break;
645 }
646 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
647 const char* ppFormats[] = { "SANE_FRAME_GRAY", "SANE_FRAME_RGB",
648 "SANE_FRAME_RED", "SANE_FRAME_GREEN",
649 "SANE_FRAME_BLUE", "Unknown !!!" };
650 fprintf( stderr, "Parameters for frame %d:\n", nStream );
651 if( aParams.format < 0 || aParams.format > 4 )
652 aParams.format = (SANE_Frame)5;
653 fprintf( stderr, "format: %s\n", ppFormats[ (int)aParams.format ] );
654 fprintf( stderr, "last_frame: %s\n", aParams.last_frame ? "TRUE" : "FALSE" );
655 fprintf( stderr, "depth: %d\n", (int)aParams.depth );
656 fprintf( stderr, "pixels_per_line: %d\n", (int)aParams.pixels_per_line );
657 fprintf( stderr, "bytes_per_line: %d\n", (int)aParams.bytes_per_line );
658 #endif
659 if( ! pBuffer )
660 {
661 pBuffer = new sal_uInt8[ BYTE_BUFFER_SIZE < 4*aParams.bytes_per_line ? 4*aParams.bytes_per_line : BYTE_BUFFER_SIZE ];
662 }
663
664 if( aParams.last_frame )
665 nStream=3;
666
667 switch( aParams.format )
668 {
669 case SANE_FRAME_GRAY:
670 eType = FrameStyle_Gray;
671 if( aParams.depth == 1 )
672 eType = FrameStyle_BW;
673 break;
674 case SANE_FRAME_RGB:
675 eType = FrameStyle_RGB;
676 break;
677 case SANE_FRAME_RED:
678 case SANE_FRAME_GREEN:
679 case SANE_FRAME_BLUE:
680 eType = FrameStyle_Separated;
681 break;
682 default:
683 fprintf( stderr, "Warning: unknown frame style !!!\n" );
684 }
685
686 sal_Bool bSynchronousRead = sal_True;
687
688 // should be fail safe, but ... ??
689 nStatus = p_set_io_mode( maHandle, SANE_FALSE );
690 CheckConsistency( "sane_set_io_mode" );
691 if( nStatus != SANE_STATUS_GOOD )
692 {
693 bSynchronousRead = sal_False;
694 nStatus = p_set_io_mode( maHandle, SANE_TRUE );
695 CheckConsistency( "sane_set_io_mode" );
696 #if (OSL_DEBUG_LEVEL > 1) || defined DBG_UTIL
697 if( nStatus != SANE_STATUS_GOOD )
698 // what ?!?
699 fprintf( stderr, "Sane::Start: driver is confused\n" );
700 #endif
701 }
702
703 SANE_Int nLen=0;
704 SANE_Int fd = 0;
705
706 if( ! bSynchronousRead )
707 {
708 nStatus = p_get_select_fd( maHandle, &fd );
709 DUMP_STATE( nStatus, "sane_get_select_fd" );
710 CheckConsistency( "sane_get_select_fd" );
711 if( nStatus != SANE_STATUS_GOOD )
712 bSynchronousRead = sal_True;
713 }
714 FILE* pFrame = tmpfile();
715 if( ! pFrame )
716 {
717 bSuccess = sal_False;
718 break;
719 }
720 do {
721 if( ! bSynchronousRead )
722 {
723 fd_set fdset;
724 struct timeval tv;
725
726 FD_ZERO( &fdset );
727 FD_SET( (int)fd, &fdset );
728 tv.tv_sec = 5;
729 tv.tv_usec = 0;
730 if( select( fd+1, &fdset, NULL, NULL, &tv ) == 0 )
731 fprintf( stderr, "Timout on sane_read descriptor\n" );
732 }
733 nLen = 0;
734 nStatus = p_read( maHandle, pBuffer, BYTE_BUFFER_SIZE, &nLen );
735 CheckConsistency( "sane_read" );
736 if( nLen && ( nStatus == SANE_STATUS_GOOD ||
737 nStatus == SANE_STATUS_EOF ) )
738 {
739 fwrite( pBuffer, 1, nLen, pFrame );
740 }
741 else
742 DUMP_STATE( nStatus, "sane_read" );
743 } while( nStatus == SANE_STATUS_GOOD );
744 if( nStatus != SANE_STATUS_EOF )
745 {
746 fclose( pFrame );
747 bSuccess = sal_False;
748 break;
749 }
750
751 int nFrameLength = ftell( pFrame );
752 fseek( pFrame, 0, SEEK_SET );
753 sal_uInt32 nWidth = (sal_uInt32) aParams.pixels_per_line;
754 sal_uInt32 nHeight = (sal_uInt32) (nFrameLength / aParams.bytes_per_line);
755 if( ! bWidthSet )
756 {
757 if( ! fResl )
758 fResl = 300; // if all else fails that's a good guess
759 if( ! nWidthMM )
760 nWidthMM = (int)(((double)nWidth / fResl) * 25.4);
761 if( ! nHeightMM )
762 nHeightMM = (int)(((double)nHeight / fResl) * 25.4);
763 #if OSL_DEBUG_LEVEL > 1
764 fprintf( stderr, "set dimensions to (%d, %d) Pixel, (%d, %d) mm, resolution is %lg\n", (int)nWidth, (int)nHeight, (int)nWidthMM, (int)nHeightMM, fResl );
765 #endif
766
767 aConverter.Seek( 18 );
768 aConverter << (sal_uInt32)nWidth;
769 aConverter << (sal_uInt32)nHeight;
770 aConverter.Seek( 38 );
771 aConverter << (sal_uInt32)(1000*nWidth/nWidthMM);
772 aConverter << (sal_uInt32)(1000*nHeight/nHeightMM);
773 bWidthSet = sal_True;
774 }
775 aConverter.Seek(60);
776
777 if( eType == FrameStyle_BW )
778 {
779 aConverter.Seek( 10 );
780 aConverter << (sal_uInt32)64;
781 aConverter.Seek( 28 );
782 aConverter << (sal_uInt16) 1;
783 aConverter.Seek( 54 );
784 // write color table
785 aConverter << (sal_uInt16)0xffff;
786 aConverter << (sal_uInt8)0xff;
787 aConverter << (sal_uInt8)0;
788 aConverter << (sal_uInt32)0;
789 aConverter.Seek( 64 );
790 }
791 else if( eType == FrameStyle_Gray )
792 {
793 aConverter.Seek( 10 );
794 aConverter << (sal_uInt32)1084;
795 aConverter.Seek( 28 );
796 aConverter << (sal_uInt16) 8;
797 aConverter.Seek( 54 );
798 // write color table
799 for( nLine = 0; nLine < 256; nLine++ )
800 {
801 aConverter << (sal_uInt8)nLine;
802 aConverter << (sal_uInt8)nLine;
803 aConverter << (sal_uInt8)nLine;
804 aConverter << (sal_uInt8)0;
805 }
806 aConverter.Seek( 1084 );
807 }
808
809 for( nLine = nHeight-1;
810 nLine >= 0; nLine-- )
811 {
812 fseek( pFrame, nLine * aParams.bytes_per_line, SEEK_SET );
813 if( eType == FrameStyle_BW ||
814 ( eType == FrameStyle_Gray && aParams.depth == 8 )
815 )
816 {
817 fread( pBuffer, 1, aParams.bytes_per_line, pFrame );
818 aConverter.Write( pBuffer, aParams.bytes_per_line );
819 }
820 else if( eType == FrameStyle_Gray )
821 {
822 for( i = 0; i < (aParams.pixels_per_line); i++ )
823 {
824 sal_uInt8 nGray = _ReadValue( pFrame, aParams.depth );
825 aConverter << nGray;
826 }
827 }
828 else if( eType == FrameStyle_RGB )
829 {
830 for( i = 0; i < (aParams.pixels_per_line); i++ )
831 {
832 sal_uInt8 nRed, nGreen, nBlue;
833 nRed = _ReadValue( pFrame, aParams.depth );
834 nGreen = _ReadValue( pFrame, aParams.depth );
835 nBlue = _ReadValue( pFrame, aParams.depth );
836 aConverter << nBlue;
837 aConverter << nGreen;
838 aConverter << nRed;
839 }
840 }
841 else if( eType == FrameStyle_Separated )
842 {
843 for( i = 0; i < (aParams.pixels_per_line); i++ )
844 {
845 sal_uInt8 nValue = _ReadValue( pFrame, aParams.depth );
846 switch( aParams.format )
847 {
848 case SANE_FRAME_RED:
849 aConverter.SeekRel( 2 );
850 aConverter << nValue;
851 break;
852 case SANE_FRAME_GREEN:
853 aConverter.SeekRel( 1 );
854 aConverter << nValue;
855 aConverter.SeekRel( 1 );
856 break;
857 case SANE_FRAME_BLUE:
858 aConverter << nValue;
859 aConverter.SeekRel( 2 );
860 break;
861 case SANE_FRAME_GRAY:
862 case SANE_FRAME_RGB:
863 break;
864 }
865 }
866 }
867 int nGap = aConverter.Tell() & 3;
868 if( nGap )
869 aConverter.SeekRel( 4-nGap );
870 }
871 fclose( pFrame ); // deletes tmpfile
872 if( eType != FrameStyle_Separated )
873 break;
874 }
875 else
876 bSuccess = sal_False;
877 }
878 // get stream length
879 aConverter.Seek( STREAM_SEEK_TO_END );
880 int nPos = aConverter.Tell();
881
882 aConverter.Seek( 2 );
883 aConverter << (sal_uInt32) nPos+1;
884 aConverter.Seek( 0 );
885
886 rBitmap.unlock();
887
888 if( bSuccess )
889 {
890 // only cancel a successful operation
891 // sane disrupts memory else
892 p_cancel( maHandle );
893 CheckConsistency( "sane_cancel" );
894 }
895 if( pBuffer )
896 delete [] pBuffer;
897
898 ReloadOptions();
899
900
901 dbg_msg( "Sane::Start returns with %s\n", bSuccess ? "TRUE" : "FALSE" );
902
903 return bSuccess;
904 }
905
GetRange(int n,double * & rpDouble)906 int Sane::GetRange( int n, double*& rpDouble )
907 {
908 if( mppOptions[n]->constraint_type != SANE_CONSTRAINT_RANGE &&
909 mppOptions[n]->constraint_type != SANE_CONSTRAINT_WORD_LIST )
910 {
911 return -1;
912 }
913
914 rpDouble = 0;
915 int nItems, i;
916 sal_Bool bIsFixed = mppOptions[n]->type == SANE_TYPE_FIXED ? sal_True : sal_False;
917
918 dbg_msg( "Sane::GetRange of option %s ", mppOptions[n]->name );
919 if(mppOptions[n]->constraint_type == SANE_CONSTRAINT_RANGE )
920 {
921 double fMin, fMax, fQuant;
922 if( bIsFixed )
923 {
924 fMin = SANE_UNFIX( mppOptions[n]->constraint.range->min );
925 fMax = SANE_UNFIX( mppOptions[n]->constraint.range->max );
926 fQuant = SANE_UNFIX( mppOptions[n]->constraint.range->quant );
927 }
928 else
929 {
930 fMin = (double)mppOptions[n]->constraint.range->min;
931 fMax = (double)mppOptions[n]->constraint.range->max;
932 fQuant = (double)mppOptions[n]->constraint.range->quant;
933 }
934 if( fQuant != 0.0 )
935 {
936 dbg_msg( "quantum range [ %lg ; %lg ; %lg ]\n",
937 fMin, fQuant, fMax );
938 nItems = (int)((fMax - fMin)/fQuant)+1;
939 rpDouble = new double[ nItems ];
940 double fValue = fMin;
941 for( i = 0; i < nItems; i++, fValue += fQuant )
942 rpDouble[i] = fValue;
943 rpDouble[ nItems-1 ] = fMax;
944 return nItems;
945 }
946 else
947 {
948 dbg_msg( "normal range [ %lg %lg ]\n",
949 fMin, fMax );
950 rpDouble = new double[2];
951 rpDouble[0] = fMin;
952 rpDouble[1] = fMax;
953 return 0;
954 }
955 }
956 else
957 {
958 nItems = mppOptions[n]->constraint.word_list[0];
959 rpDouble = new double[nItems];
960 for( i=0; i<nItems; i++ )
961 {
962 rpDouble[i] = bIsFixed ?
963 SANE_UNFIX( mppOptions[n]->constraint.word_list[i+1] ) :
964 (double)mppOptions[n]->constraint.word_list[i+1];
965 }
966 dbg_msg( "wordlist [ %lg ... %lg ]\n",
967 rpDouble[ 0 ], rpDouble[ nItems-1 ] );
968 return nItems;
969 }
970 }
971
972 static const char *ppUnits[] = {
973 "",
974 "[Pixel]",
975 "[Bit]",
976 "[mm]",
977 "[DPI]",
978 "[%]",
979 "[usec]"
980 };
981
GetOptionUnitName(int n)982 String Sane::GetOptionUnitName( int n )
983 {
984 String aText;
985 SANE_Unit nUnit = mppOptions[n]->unit;
986 size_t nUnitAsSize = (size_t)nUnit;
987 if (nUnitAsSize >= sizeof(ppUnits)/sizeof(ppUnits[0]))
988 aText = String::CreateFromAscii( "[unknown units]" );
989 else
990 aText = String( ppUnits[ nUnit ], gsl_getSystemTextEncoding() );
991 return aText;
992 }
993
ActivateButtonOption(int n)994 sal_Bool Sane::ActivateButtonOption( int n )
995 {
996 SANE_Status nStatus = ControlOption( n, SANE_ACTION_SET_VALUE, NULL );
997 if( nStatus != SANE_STATUS_GOOD )
998 return sal_False;
999 return sal_True;
1000 }
1001