wxscan.cpp

Go to the documentation of this file.

/***************************************************************
 * Name:      wxscan.cpp
 * Purpose:   wxWidgets wrapper around libsane (for scanner
 *            access)
 * Author:    Daniel Nell (daniel.nell@nellresearch.de)
 * Created:   2008-05-04
 * Copyright: Daniel Nell (www.nellresearch.de)
 * License:   wxWindows license
 **************************************************************/

// Include headers.
#include "wx_pch.h"
#include "wxscan.h"


#if defined( __UNIX_LIKE__ )
//////////////////////////////////////////////////////////
// Class wxScanSane
//
// Standard constructor.
//
wxScanSane::wxScanSane( bool bOnlyLocalDevices )
{
    // Initialize members.
    m_bOnlyLocalDevices= bOnlyLocalDevices;
    m_nResolution= -1; // Invalid value for resolution.

    // Initialize SANE.
    m_SaneStatus= ::sane_init( NULL, NULL );

    // Get the device list from SANE subsystem.
    SaneGetDevices();
}

// Virtual destructor.
//
wxScanSane::~wxScanSane()
{
    // Close the SANE sub system.
    ::sane_exit();
}

// Get an image from the scanning device.
//
bool wxScanSane::ScanImage( wxImage& oImage )
{
    // Check if there is a proper device index.
    if( !IsDeviceAvailable() )
    {
        // Log and signal error.
        wxLogError( wxString( wxT( "bool wxScan::ScanImage() - " ) )
                      + _( "SANE device not available." ) );
        return false;
    }

#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 3
    for( int i= 0; i < m_nDeviceCount; i++ )
    {
        if( i != m_nDeviceIndex )
        {
            wxLogMessage( wxT( "SANE DEVICE" ) );
            wxLogMessage( wxT( "\tname == " )   + GetDeviceName(   i ) );
            wxLogMessage( wxT( "\tvendor == " ) + GetDeviceVendor( i ) );
            wxLogMessage( wxT( "\tmodel == " )  + GetDeviceModel(  i ) );
            wxLogMessage( wxT( "\ttype == " )   + GetDeviceType(   i ) );
            wxLogMessage( wxT( "============" ) );
        }
    }
    ::wxSafeYield();
#endif

#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 1
    wxLogMessage( wxT( "DEFAULT SANE DEVICE" ));
    wxLogMessage( wxT( "\tname == " )   + GetDeviceName(   m_nDeviceIndex ) );
    wxLogMessage( wxT( "\tvendor == " ) + GetDeviceVendor( m_nDeviceIndex ) );
    wxLogMessage( wxT( "\tmodel == " )  + GetDeviceModel(  m_nDeviceIndex ) );
    wxLogMessage( wxT( "\ttype == " )   + GetDeviceType(   m_nDeviceIndex ) );
    wxLogMessage( wxT( "============" ) );
    ::wxSafeYield();
#endif

    // Sane device handle.
    SANE_Handle hSaneHandle;

    // Open the sane device...
    m_SaneStatus= ::sane_open( GetDeviceName( m_nDeviceIndex ).mb_str( wxConvISO8859_1 ), &hSaneHandle );
    if( !IsOk() )
    {
        // Log and signal error.
        wxLogError( GetSaneStatusString() + wxT( " (SANE)" ) );
        return false;
    }

    // ... and start scanning.
    m_SaneStatus= ::sane_start( hSaneHandle );
    if( !IsOk() )
    {
        // Log and signal error.
        wxLogError( GetSaneStatusString() + wxT( " (SANE)" ) );
        return false;
    }

    // Get scanning parameters e. g. width, height, color depth etc.
    SANE_Parameters oSaneParameters;

    ::sane_get_parameters( hSaneHandle, &oSaneParameters );

#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 1
    wxLogMessage( wxT( "SCANNING PARAMETERS" ) );
    wxLogMessage( wxString::Format( wxT( "\tformat = %d" ), oSaneParameters.format ) );
    wxLogMessage( wxString::Format( wxT( "\tlast_frame = %d" ), oSaneParameters.last_frame ) );
    wxLogMessage( wxString::Format( wxT( "\tbytes_per_line = %d" ), oSaneParameters.bytes_per_line ) );
    wxLogMessage( wxString::Format( wxT( "\tpixels_per_line = %d" ), oSaneParameters.pixels_per_line ) );
    wxLogMessage( wxString::Format( wxT( "\tlines = %d" ), oSaneParameters.lines ) );
    wxLogMessage( wxString::Format( wxT( "\tdepth = %d" ), oSaneParameters.depth ) );
    wxLogMessage( wxT( "============" ) );
    ::wxSafeYield();
#endif

    // Check format information.
    //
    // Note: At the moment we only support RGB/8-bit-per-pixel scans.
    if(
           !oSaneParameters.last_frame
        || ( oSaneParameters.format != SANE_FRAME_RGB )
        || ( oSaneParameters.depth != oSaneParameters.depth )
      )
    {
        // Log and signal error.
        wxLogError( wxString( wxT( "bool wxScan::ScanImage() - " ) )
                      + _( "Formats other than RGB with 8 bit per pixel are not yet supported." ) );
        return false;
    }

    // Create scan buffer.
    int nImageBufferSize= ( oSaneParameters.pixels_per_line * oSaneParameters.lines * 3 + 1 ) * sizeof( SANE_Byte );
    SANE_Byte *pScanBuffer= (SANE_Byte *)malloc( nImageBufferSize );

    if( !pScanBuffer )
    {
        // Log and signal error.
        wxLogError( wxString( wxT( "bool wxScan::ScanImage() - " ) )
                      + _( "Cannot allocate read buffer." ) );
        return false;
    }

    // Read image from scanner.
    SANE_Int nScannedBytes;
    SANE_Byte *pScanBufferPtr= pScanBuffer;

    do
    {
        m_SaneStatus= ::sane_read( hSaneHandle, pScanBufferPtr, nImageBufferSize, &nScannedBytes );
        pScanBufferPtr += nScannedBytes * sizeof( SANE_Byte );
    } while( ( m_SaneStatus != SANE_STATUS_EOF ) && ( m_SaneStatus == SANE_STATUS_GOOD ) ) ;
    if( ( m_SaneStatus !=  SANE_STATUS_EOF ) )
    {
        // Log, clean up, and signal error.
        wxLogError( wxString( wxT( "bool wxScan::ScanImage() - " ) )
                      + _( "An error occured while fetching data from scanning device." ) );
        ::sane_cancel( hSaneHandle );
        free( pScanBuffer );
        return false;
    }
    m_SaneStatus= SANE_STATUS_GOOD;

    // Save the image in the result image.
    wxImage oNewImage( oSaneParameters.pixels_per_line, oSaneParameters.lines, pScanBuffer );

    oImage= oNewImage;

    // Get the image resoltuion;
    m_nResolution= -1;

    int nOptionCount;
    const SANE_Option_Descriptor *oSaneOptionDescriptor;

    ::sane_control_option( hSaneHandle, 0, SANE_ACTION_GET_VALUE, &nOptionCount, NULL );
    for( int i= 0; i < nOptionCount; i++ )
    {
            oSaneOptionDescriptor= ::sane_get_option_descriptor( hSaneHandle, i );

            wxString strOption( SANE_STRING_TO_WXSTRING( oSaneOptionDescriptor->name ) );

#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 2
            wxLogMessage( wxT( "DEVICE OPTION DESCRIPTOR %d" ), i );
            wxLogMessage( strOption + wxString::Format( wxT( "(%d):" ), oSaneOptionDescriptor->size ) );
            wxLogMessage( wxT( "\t" ) + SANE_STRING_TO_WXSTRING( oSaneOptionDescriptor->title ) );
            wxLogMessage( wxT( "\t" ) + SANE_STRING_TO_WXSTRING( oSaneOptionDescriptor->desc  ) );
#endif
            if( 0 == strOption.CompareTo( wxT( "resolution" ) ) )
            {
                switch( oSaneOptionDescriptor->type )
                {
                    case SANE_TYPE_INT :    {
                                                int nValue;

                                                ::sane_control_option( hSaneHandle, i, SANE_ACTION_GET_VALUE, &nValue, NULL );
                                                m_nResolution= (int)nValue;
                                            }
                                            break;
                    case SANE_TYPE_FIXED :  {
                                                SANE_Fixed   nValue;

                                                ::sane_control_option( hSaneHandle, i, SANE_ACTION_GET_VALUE, &nValue, NULL );
                                                m_nResolution= (int)nValue;
                                            }
                                            break;
                    default :               {
                                                // [Nothing to do, yet.]
                                            }
                }
#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 1
                wxLogMessage( wxT( "\tresolution == %d DPI" ), m_nResolution );
#endif
            }
#if defined( __WXSCANDEBUG__ ) && __WXSCANDEBUG__ >= 2
            wxLogMessage( wxT( "============" ) );
#endif
    }

    if( m_nResolution > 0 )
    {
        oImage.SetOption( wxIMAGE_OPTION_RESOLUTIONUNIT, wxIMAGE_RESOLUTION_INCHES );
        oImage.SetOption( wxIMAGE_OPTION_RESOLUTIONX,    m_nResolution );
        oImage.SetOption( wxIMAGE_OPTION_RESOLUTIONY,    m_nResolution );
        oImage.SetOption( wxIMAGE_OPTION_RESOLUTION,     m_nResolution );
    }

    // Close the sane device.
    ::sane_close( hSaneHandle );

    // Return the state.
    return IsOk();
}

// Select the scanning device by index number.
//
bool wxScanSane::SetDeviceIndex( int nIndex )
{
    int nOldIndex= m_nDeviceIndex;

    m_nDeviceIndex= nIndex;

    bool nRetCode= IsDeviceAvailable();

    if( !nRetCode );
    {
        m_nDeviceIndex= nOldIndex;
    }

    return nRetCode;
}

// Fill the SANE device list.
//
bool wxScanSane::SaneGetDevices()
{
    // Get the device list from sane subsystem...
    m_SaneStatus= ::sane_get_devices( &m_ppDeviceList, m_bOnlyLocalDevices );
    if( !IsOk() )
    {
        // Log error.
        wxLogError( GetSaneStatusString() + wxT( " (SANE)" ) );
        return false ;
    }

    // ... and count the devices.
    for( m_nDeviceCount=0; m_ppDeviceList[m_nDeviceCount]; m_nDeviceCount++ )
    {
    }

    // Initialize device index (default device);
    m_nDeviceIndex= m_nDeviceCount > 0 ? 0 : -1;

    // Return the state.
    return IsOk();
}
#endif // __UNIX_LIKE__

#if defined( __WXMSW__ )
// Standard constructor.
//
// ...
#endif // __WXMSW__