command line capturer now seems to work

you can now write yourself a nice webcam application :)

4 files changed, 156 insertions, 63 deletions

diff --git a/noncore/multimedia/camera/cmd/capture.cpp b/noncore/multimedia/camera/cmd/capture.cpp
index 7960bbb..64c223c 100644
--- a/noncore/multimedia/camera/cmd/capture.cpp
+++ b/noncore/multimedia/camera/cmd/capture.cpp
@@ -4,143 +4,187 @@
 ** This file is part of Opie Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** 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 "capture.h"
+
 #include "zcameraio.h"
 #include "imageio.h"
 #include "avi.h"
 
-#include <qfile.h>
-#include <qimage.h>
 #include <opie2/oapplication.h>
+#include <opie2/odebug.h>
+
+#include <qimage.h>
 
-#include <assert.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <string.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdio.h>
+Capturer::Capturer()
+         :QFrame( 0 ), height( 320 ), width( 240 ), zoom( 1 ), quality( 90 ),
+         flip( "A" ), format( "JPEG" ), name( "Untitled" )
+{
+}
 
-#define CAPTUREFILE "/tmp/capture.dat"
-#define OUTPUTFILE  "/tmp/output.avi"
 
-int captureX = 240;
-int captureY = 320;
-int quality = 75;
-QString flip = "A";
-int zoom = 1;
-QString format = "JPG";
-QString name;
+Capturer::~Capturer()
+{
+}
+
+
+void Capturer::checkSettings()
+{
+    if ( width > height )
+    {
+        if ( 0 != width % 16 || width < 16 || width > 640 )
+        {
+            printf( "Warning: Corrected X resolution to 320 px\n" );
+            width = 320;
+        }
+        if ( 0 != height % 16 || height < 16 || height > 480 )
+        {
+            printf( "Warning: Corrected Y resolution to 240 px\n" );
+            height = 240;
+        }
+    }
+    else
+    {
+        if ( 0 != width % 16 || width < 16 || width > 480 )
+        {
+            printf( "Warning: Corrected X resolution to 240 px\n" );
+            width = 240;
+        }
+        if ( 0 != height % 16 || height < 16 || height > 640 )
+        {
+            printf( "Warning: Corrected Y resolution to 320 px\n" );
+            height = 320;
+        }
+    }
+
+    if ( quality > 100 || quality < 10 )
+    {
+        printf( "Warning: Corrected quality to 75%%\n" );
+        quality = 75;
+    }
+
+    if ( zoom > 2 || zoom < 1 )
+    {
+        printf( "Warning: Corrected zoom to x1\n" );
+        zoom = 1;
+    }
+
+    if ( format != "JPEG" && format != "PNG" && format != "BMP" )
+    {
+        printf( "Warning: Corrected format to 'JPEG'\n" );
+        format = "JPEG";
+    }
+}
+
+
+void Capturer::capture()
+{
+    if ( flip == "A" )
+        ZCameraIO::instance()->setFlip( ZCameraIO::AUTOMATICFLIP );
+    else if ( flip == "0" )
+        ZCameraIO::instance()->setFlip( ZCameraIO::XNOFLIP | ZCameraIO::YNOFLIP );
+    else if ( flip == "X" )
+        ZCameraIO::instance()->setFlip( ZCameraIO::XFLIP );
+    else if ( flip == "Y" )
+        ZCameraIO::instance()->setFlip( ZCameraIO::YFLIP );
+    else if ( flip == "*" )
+        ZCameraIO::instance()->setFlip( ZCameraIO::XFLIP | ZCameraIO::YFLIP );
+
+    ZCameraIO::instance()->captureFrame( width, height, zoom, &image );
+    QImage im = image.convertDepth( 32 );
+    bool result = im.save( name, format, quality );
+    if ( !result )
+    {
+        printf( "QImageio-Problem while writing.\n" );
+    }
+    else
+    {
+        printf( "Ok.\n" );
+    }
+}
 
-int performCapture();
 
 void usage()
 {
     printf( "Usage: ./capture [options] filename\n\n" );
     printf( "  -x xresolution (dividable by 16) [default=240]\n" );
     printf( "  -y xresolution (dividable by 16) [default=320]\n" );
     printf( "  -q quality (10-100) [default=75]\n" );
-    printf( "  -f flip (A=auto, X, Y, *=both) [default=Auto]\n" );
-    printf( "  -o output format (JPG,BMP,PNG) [default=JPG]\n" );
+    printf( "  -f flip (A=auto, 0, X, Y, *=both) [default=Auto]\n" );
+    printf( "  -o output format (JPEG,BMP,PNG) [default=JPEG]\n" );
     printf( "  -z zoom (1-2) [default=1]\n" );
 }
 
 int main( int argc, char** argv )
 {
-    OApplication* a = new OApplication( argc, argv, "opie-camera" );
+    OApplication* a = new OApplication( argc, argv, "Capture" );
+    Capturer* c = new Capturer();
 
     if ( argc < 2 )
     {
         usage();
         return -1;
     }
 
-    int captureX = 240;
-    int captureY = 320;
-    QString flip = "A";
-
     #define I_HATE_WRITING_HARDCODED_PARSES
 
     int i = 1;
     while ( i < argc )
     {
         // check for filename
         if ( argv[i][0] != '-' )
         {
             if ( argc != i+1 )
             {
                 usage();
                 return -1;
             }
             else
             {
-                name = argv[i];
+                c->name = argv[i];
                 break;
             }
         }
         else
         {
             i++;
             if ( argc == i )
             {
                 usage();
                 return -1;
             }
             switch ( argv[i-1][1] )
             {
-                case 'x': captureX = QString( argv[i] ).toInt(); break;
-                case 'y': captureY = QString( argv[i] ).toInt(); break;
-                case 'z': zoom = QString( argv[i] ).toInt(); break;
-                case 'o': format = QString( argv[i] ); break;
-                case 'q': quality = QString( argv[i] ).toInt(); break;
-                case 'f': flip = QString( argv[i] )[0]; break;
+                case 'x': c->width = QString( argv[i] ).toInt(); break;
+                case 'y': c->height = QString( argv[i] ).toInt(); break;
+                case 'z': c->zoom = QString( argv[i] ).toInt(); break;
+                case 'o': c->format = QString( argv[i] ); break;
+                case 'q': c->quality = QString( argv[i] ).toInt(); break;
+                case 'f': c->flip = QString( argv[i] )[0]; break;
                 default: usage(); return -1;
             }
             i++;
         }
 
     #undef I_HATE_WRITING_HARDCODED_PARSES
     }
 
     if ( !ZCameraIO::instance()->isOpen() )
     {
         printf( "Error: Can't detect your camera. Exiting.\n" );
         return -1;
     }
-    return performCapture();
-}
-
 
-int performCapture()
-{
-   printf( "Capturing %dx%d Image [%s] q%d z%d --> %s\n", captureX,
-                                                          captureY,
-                                                          (const char*) format,
-                                                          quality,
-                                                          zoom,
-                                                          (const char*) name );
-
-    QImage i;
-    ZCameraIO::instance()->captureFrame( captureX, captureY, zoom, &i );
-    QImage im = i.convertDepth( 32 );
-    bool result = im.save( name, format, quality );
-    if ( !result )
-    {
-        printf( "QImageio-Problem while writing.\n" );
-        return -1;
-    }
-    else
-    {
-        printf( "Ok.\n" );
-    }
+    c->checkSettings();
+    c->capture();
+    return 0;
 }
 
diff --git a/noncore/multimedia/camera/cmd/capture.h b/noncore/multimedia/camera/cmd/capture.h
new file mode 100644
index 0000000..f23aca0
--- a/dev/null
+++ b/noncore/multimedia/camera/cmd/capture.h
@@ -0,0 +1,45 @@
+/**********************************************************************
+** Copyright (C) 2003 Michael 'Mickey' Lauer.  All rights reserved.
+**
+** This file is part of Opie Environment.
+**
+** This file may be distributed and/or modified under the terms of the
+** GNU General Public License version 2 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.
+**
+** 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 "zcameraio.h"
+#include "imageio.h"
+#include "avi.h"
+
+#include <qfile.h>
+#include <qframe.h>
+#include <qimage.h>
+
+class Capturer: public QFrame
+{
+  Q_OBJECT
+
+  public:
+    Capturer();
+    virtual ~Capturer();
+
+    int height;
+    int width;
+    int zoom;
+    int quality;
+    QString flip;
+    QString format;
+    QString name;
+    QImage image;
+
+  public slots:
+    void capture();
+    void checkSettings();
+};
+
diff --git a/noncore/multimedia/camera/cmd/cmd.pro b/noncore/multimedia/camera/cmd/cmd.pro
index 3b1aaa6..a5791f4 100644
--- a/noncore/multimedia/camera/cmd/cmd.pro
+++ b/noncore/multimedia/camera/cmd/cmd.pro
@@ -1,18 +1,18 @@
 MOC_DIR         = ./moc
 OBJECTS_DIR     = ./obj
 DESTDIR         = $(OPIEDIR)/bin
 TEMPLATE        = app
 CONFIG          = qt warn_on debug
 
-HEADERS         = 
+HEADERS         = capture.h
 
 SOURCES         = capture.cpp
 
 INCLUDEPATH     += $(OPIEDIR)/include ../lib
 DEPENDPATH      += $(OPIEDIR)/include ../lib
-LIBS            += -lqpe -lopiecore2 -lopiecam
+LIBS            += -lopiecore2 -lopiecam
 INTERFACES      =
 TARGET          = capture
 
 include ( $(OPIEDIR)/include.pro )
 
diff --git a/noncore/multimedia/camera/lib/zcameraio.cpp b/noncore/multimedia/camera/lib/zcameraio.cpp
index c940b45..d59cbbb 100644
--- a/noncore/multimedia/camera/lib/zcameraio.cpp
+++ b/noncore/multimedia/camera/lib/zcameraio.cpp
@@ -130,24 +130,25 @@ bool ZCameraIO::setCaptureFrame( int width, int height, int zoom, bool rot )
     odebug << "setCaptureFrame( " << width << ", " << height << ", " << zoom << ", " << rot << " )" << oendl;
     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;
     }
+    owarn << "couldn't write to driver" << oendl;
     return false;
 }
 
 
 bool ZCameraIO::setZoom( int zoom )
 {
     return setCaptureFrame( _width, _height, zoom*256, _rot );
 }
 
 
 void ZCameraIO::setReadMode( int mode )
 {
@@ -206,24 +207,26 @@ bool ZCameraIO::write( char* buf, int len )
 
     return ::write( _driver, buf, len ) == len;
 }
 
 
 bool ZCameraIO::snapshot( QImage* image )
 {
     setReadMode( STATUS );
 
     odebug << "finder reversed = " << isFinderReversed() << oendl;
     odebug << "rotation = " << _rot << oendl;
 
+    odebug << "w=" << _width << " h= " << _height << " readlen= " << _readlen << oendl;
+
     int readmode;
     if ( _flip == -1 ) // AUTO
     {
         if ( _rot ) // Portrait
         {
             readmode = IMAGE | isFinderReversed() ? XFLIP | YFLIP : 0;
         }
         else // Landscape
         {
             readmode = IMAGE | XFLIP | YFLIP;
         }
     }
@@ -282,29 +285,30 @@ bool ZCameraIO::snapshot( unsigned char* buf )
     {
         readmode = IMAGE | _flip;
     }
 
     setReadMode( readmode );
     read( (char*) buf, _readlen );
 
 }
 
 
 void ZCameraIO::captureFrame( int w, int h, int zoom, QImage* image )
 {
+    int prot = _rot;
     int pw = _width;
     int ph = _height;
-    setCaptureFrame( w, h, zoom*256, _rot );
+    setCaptureFrame( w, h, zoom*256, w<h );
     snapshot( image );
-    setCaptureFrame( pw, ph, _zoom, _rot );
+    setCaptureFrame( pw, ph, _zoom, prot );
 }
 
 
 void ZCameraIO::captureFrame( int w, int h, int zoom, unsigned char* buf )
 {
     //FIXME: this is too slow
     int pw = _width;
     int ph = _height;
     setCaptureFrame( w, h, zoom*256, _rot );
     snapshot( buf );
     setCaptureFrame( pw, ph, _zoom, _rot );
 }