implementation of camera API as described in the Sharp Camera API document nearly completed

3 files changed, 166 insertions, 13 deletions

diff --git a/noncore/multimedia/camera/mainwindow.cpp b/noncore/multimedia/camera/mainwindow.cpp
index 2cca9f9..4218232 100644
--- a/noncore/multimedia/camera/mainwindow.cpp
+++ b/noncore/multimedia/camera/mainwindow.cpp
@@ -11,24 +11,26 @@
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "mainwindow.h"
 #include "zcameraio.h"
 
 #include <qvbox.h>
 #include <qpushbutton.h>
 #include <qlabel.h>
 
+#include <qdirectpainter_qws.h>
+
 #include <qpe/resource.h>
 #include <opie/ofiledialog.h>
 
 CameraMainWindow::CameraMainWindow( QWidget * parent, const char * name, WFlags f )
            :QMainWindow( parent, name, f )
 {
     QVBox* v = new QVBox( this );
     l = new QLabel( v );
     l->setFixedSize( QSize( 240, 160 ) );
     QPushButton* p = new QPushButton( "Snapshot", v );
     connect( p, SIGNAL( clicked() ), this, SLOT( clickedSnapShot() ) );
     v->show();
@@ -37,21 +39,26 @@ CameraMainWindow::CameraMainWindow( QWidget * parent, const char * name, WFlags
     setCentralWidget( v );
 
 };
 
 
 CameraMainWindow::~CameraMainWindow()
 {
 }
 
 
 void CameraMainWindow::clickedSnapShot()
 {
+    QDirectPainter fb( l );
+    ZCameraIO::instance()->snapshot( fb.frameBuffer() );
+
+    /*
     QImage i;
     QPixmap p;
     if ( ZCameraIO::instance()->snapshot( &i ) )
     {
         p.convertFromImage( i );
         l->setPixmap( p );
     }
+    */
 }
 
diff --git a/noncore/multimedia/camera/zcameraio.cpp b/noncore/multimedia/camera/zcameraio.cpp
index e74136f..7343dca 100644
--- a/noncore/multimedia/camera/zcameraio.cpp
+++ b/noncore/multimedia/camera/zcameraio.cpp
@@ -12,78 +12,195 @@
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #include "zcameraio.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <stdio.h>
 
 #include <qimage.h>
 
 #include <opie2/odebug.h>
 
 ZCameraIO* ZCameraIO::_instance = 0;
 
+ZCameraIO* ZCameraIO::instance()
+{
+    if ( !ZCameraIO::_instance )
+    {
+        odebug << "Creating ZCameraIO::_instance" << oendl;
+        ZCameraIO::_instance = new ZCameraIO();
+    }
+    return ZCameraIO::_instance;
+}
+
+
 ZCameraIO::ZCameraIO()
+          :_height( 0 ), _width( 0 ), _zoom( 0 ), _rot( 0 ), _readlen( 0 )
 {
-    _driver = open( "/dev/sharp_zdc", O_RDWR );
+    _driver = ::open( "/dev/sharp_zdc", O_RDWR );
     if ( _driver == -1 )
         oerr << "Can't open camera driver: " << strerror(errno) << oendl;
+    else
+        init();
+}
 
-    ZCameraIO::_instance = this;
-};
+
+void ZCameraIO::init()
+{
+    if ( ZCameraIO::_instance )
+        ofatal << "Don't create more than one ZCameraIO instances." << oendl;
+    else
+    {
+        setReadMode( STATUS );
+    }
+}
 
 
 ZCameraIO::~ZCameraIO()
 {
     if ( _driver != -1 )
-        close( _driver );
+        ::close( _driver );
+}
+
+
+inline bool ZCameraIO::isOpen() const
+{
+    return _driver != -1;
+}
+
+
+inline bool ZCameraIO::isShutterPressed()
+{
+    return _status[0] == 'S';
+    clearShutterLatch();
+}
+
+
+inline bool ZCameraIO::isFinderReversed() const
+{
+    return _status[1] == 'M';
+}
+
+
+inline bool ZCameraIO::isCapturing() const
+{
+    return _status[2] == 'C';
+}
+
+
+inline bool ZCameraIO::isAvailable() const
+{
+    return _status[3] == 'A';
+}
+
+
+bool ZCameraIO::setCaptureFrame( int width, int height, int zoom, bool rot )
+{
+    char b[100];
+    sprintf( b, "%c=%d,%d,%d,%d", rot ? 'R':'S', width, height, zoom, width*2 );
+    if ( write( b ) )
+    {
+        _width = width;
+        _height = _height;
+        _zoom = zoom;
+        _rot = rot;
+        _readlen = 2 * _width * _height; // camera is fixed @ 16 bits per pixel
+        return true;
+    }
+    return false;
+}
+
+
+void ZCameraIO::setReadMode( int mode )
+{
+    char b[4];
+    sprintf( b, "M=%d", mode );
+    write( b, mode <= 9 ? 3 : 4 );
+    if ( mode & 1 ) // STATUS bit is set
+        read( _status, 4 );
+}
+
+
+void ZCameraIO::clearShutterLatch()
+{
+    char b = 'B';
+    write( &b, 1 );
+}
+
+
+bool ZCameraIO::read( char* b, int len )
+{
+    int rlen = ::read( _driver, b, len );
+    odebug << "read " << rlen << " from driver." << oendl;
+    return rlen == len;
+}
+
+
+bool ZCameraIO::write( char* buf, int len )
+{
+    if ( !len )
+        len = strlen( buf );
+
+    odebug << "writing '" << buf << "' to driver." << oendl;
+
+    return ::write( _driver, buf, len ) == len;
 }
 
 
 bool ZCameraIO::snapshot( QImage* image )
 {
     /*
 
     char buf[76800];
 
     write( _driver, "M=13", 4 );
     write( _driver, "R=240,160,256,480", 17 );
     write( _driver, "M=12", 4 );
 
     int result = read( _driver, &buf, sizeof buf );
 
     return result == sizeof buf;
 
     */
 
-    uchar buf[76800];
-    uchar* bp = buf;
-    uchar* p;
-
+    unsigned char buf[76800];
+    unsigned char* bp = buf;
+    unsigned char* p;
 
     int fd = open( "/tmp/cam", O_RDONLY );
-    if ( read( fd, buf, sizeof buf ) != sizeof buf )
-        qDebug( "WARNING: couldn't read image!" );
+    if ( ::read( fd, buf, sizeof buf ) != sizeof buf )
+        owarn << "Couldn't read image from /dev/sharp_zdc" << oendl;
 
     image->create( 240, 160, 16 );
     for ( int i = 0; i < 160; ++i )
     {
         p = image->scanLine( i );
         for ( int j = 0; j < 240; j++ )
         {
             *p = *bp;
             p++;
             bp++;
             *p = *bp;
             p++;
             bp++;
         }
     }
 
     return true;
 }
+
+bool ZCameraIO::snapshot( uchar* buf )
+{
+    int fd = open( "/tmp/cam", O_RDONLY );
+    if ( ::read( fd, buf, 76800 ) != 76800 )
+        owarn << "Couldn't read image from /dev/sharp_zdc" << oendl;
+
+    return true;
+}
+
diff --git a/noncore/multimedia/camera/zcameraio.h b/noncore/multimedia/camera/zcameraio.h
index 1690aa6..bc4926b 100644
--- a/noncore/multimedia/camera/zcameraio.h
+++ b/noncore/multimedia/camera/zcameraio.h
@@ -12,25 +12,54 @@
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 **********************************************************************/
 
 #ifndef ZCAMERAIO_H
 #define ZCAMERAIO_H
 
 class QImage;
 
 class ZCameraIO
 {
   public:
-    ZCameraIO();
     virtual ~ZCameraIO();
 
-    bool isOpen() const { return _driver != -1; };
+    enum ReadMode
+    {
+        IMAGE = 0, STATUS = 1,
+        FASTER = 0, BETTER = 2,
+        XNOFLIP = 0, XFLIP = 4,
+        YNOFLIP = 0, YFLIP = 8
+    };
+
+    bool setCaptureFrame( int w, int h, int zoom = 256, bool rot = true );
+    void setReadMode( int = IMAGE | XFLIP | YFLIP );
+
+    bool isShutterPressed(); // not const, because it calls clearShutterLatch
+    bool isAvailable() const;
+    bool isCapturing() const;
+    bool isFinderReversed() const;
+
+    bool isOpen() const;
     bool snapshot( QImage* );
-    static ZCameraIO* instance() { return _instance; };
+    bool snapshot( unsigned char* );
+    static ZCameraIO* instance();
+
+  protected:
+    ZCameraIO();
+    void clearShutterLatch();
+    void init();
+    bool read( char*, int );
+    bool write( char*, int = 0 );
 
   private:
     int _driver;
+    char _status[4];
     static ZCameraIO* _instance;
+    int _height;
+    int _width;
+    int _zoom;
+    bool _rot;
+    int _readlen;
 };
 
 #endif