summaryrefslogtreecommitdiff
Unidiff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/multimedia/camera/avi.c235
-rw-r--r--noncore/multimedia/camera/avi.h142
-rw-r--r--noncore/multimedia/camera/camera.pro6
-rw-r--r--noncore/multimedia/camera/mainwindow.cpp162
-rw-r--r--noncore/multimedia/camera/mainwindow.h9
-rw-r--r--noncore/multimedia/camera/zcameraio.cpp11
6 files changed, 530 insertions, 35 deletions
diff --git a/noncore/multimedia/camera/avi.c b/noncore/multimedia/camera/avi.c
new file mode 100644
index 0000000..0c757c9
--- a/dev/null
+++ b/noncore/multimedia/camera/avi.c
@@ -0,0 +1,235 @@
1/**********************************************************************
2** Copyright (C) 2003 Michael 'Mickey' Lauer. All rights reserved.
3** Based on work from Andrew Tridgell and the jpegtoavi project
4**
5** This file is part of Opie Environment.
6**
7** This file may be distributed and/or modified under the terms of the
8** GNU General Public License version 2 as published by the Free Software
9** Foundation and appearing in the file LICENSE.GPL included in the
10** packaging of this file.
11**
12** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
13** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
14**
15**********************************************************************/
16
17#include "avi.h"
18
19#include <string.h>
20#include <stdio.h>
21
22int nframes;
23int totalsize;
24unsigned int* sizes;
25
26void fprint_quartet(int fd, unsigned int i)
27{
28 char data[4];
29
30 data[0] = (char) i%0x100;
31 i /= 0x100;
32 data[1] = (char) i%0x100;
33 i /= 0x100;
34 data[2] = (char) i%0x100;
35 i /= 0x100;
36 data[3] = (char) i%0x100;
37
38 write( fd, &data, 4 );
39}
40
41// start writing an AVI file
42
43void avi_start(int fd, int frames)
44{
45 int ofs = sizeof(struct riff_head)+
46 sizeof(struct list_head)+
47 sizeof(struct avi_head)+
48 sizeof(struct list_head)+
49 sizeof(struct stream_head)+
50 sizeof(struct frame_head)+
51 sizeof(struct list_head)+
52 sizeof(struct dmlh_head)+
53 sizeof(struct list_head);
54
55 printf( "avi_start: frames = %d\n", frames );
56
57 lseek(fd, ofs, SEEK_SET);
58
59 nframes = 0;
60 totalsize = 0;
61
62 sizes = (unsigned int*) calloc( sizeof(unsigned int), frames ); // hold size of each frame
63}
64
65// add a jpeg frame to an AVI file
66void avi_add(int fd, u8 *buf, int size)
67{
68 struct db_head db = {"00db", 0};
69
70 printf( "avi_add: nframes = %d, totalsize = %d, size = %d\n", nframes, totalsize, size );
71
72 // overwrite JFIF type with AVI1
73 buf[6]='A';
74 buf[7]='V';
75 buf[8]='I';
76 buf[9]='1';
77
78 while( size%4 ) size++; // align 0 modulo 4*/
79 db.size = size;
80
81 write( fd, &db, sizeof(db) );
82 write( fd, buf, size );
83
84 sizes[nframes] = size;
85
86 nframes++;
87 totalsize += size; // total frame size
88}
89
90// finish writing the AVI file - filling in the header
91void avi_end(int fd, int width, int height, int fps)
92{
93 struct idx1_head idx = {"idx1", 16*nframes };
94 struct db_head db = {"00db", 0};
95 struct riff_head rh = { "RIFF", 0, "AVI "};
96 struct list_head lh1 = {"LIST", 0, "hdrl"};
97 struct avi_head ah;
98 struct list_head lh2 = {"LIST", 0, "strl"};
99 struct stream_head sh;
100 struct frame_head fh;
101 struct list_head lh3 = {"LIST", 0, "odml" };
102 struct dmlh_head dh = {"dmlh", 4, nframes };
103 struct list_head lh4 = {"LIST", 0, "movi"};
104 int i;
105 unsigned int offset = 4;
106
107 printf( "avi_end: nframes = %d, fps = %d\n", nframes, fps );
108
109 // write index
110
111 write(fd, &idx, sizeof(idx));
112
113 for ( i = 0; i < nframes; i++ )
114 {
115 write(fd, &db, 4 ); // only need the 00db
116 fprint_quartet( fd, 18 ); // ???
117 fprint_quartet( fd, offset );
118 fprint_quartet( fd, sizes[i] );
119 offset += sizes[i];
120 }
121
122 free( sizes );
123
124 bzero( &ah, sizeof(ah) );
125 strcpy(ah.avih, "avih");
126 ah.time = 1000000 / fps;
127 ah.maxbytespersec = 1000000.0*(totalsize/nframes)/ah.time;
128 ah.numstreams = 1;
129 ah.flags = AVIF_HASINDEX;
130 ah.width = width;
131 ah.height = height;
132
133 bzero(&sh, sizeof(sh));
134 strcpy(sh.strh, "strh");
135 strcpy(sh.vids, "vids");
136 strcpy(sh.codec, "MJPG");
137 sh.scale = ah.time;
138 sh.rate = 1000000;
139 sh.length = nframes;
140
141 bzero(&fh, sizeof(fh));
142 strcpy(fh.strf, "strf");
143 fh.width = width;
144 fh.height = height;
145 fh.planes = 1;
146 fh.bitcount = 24;
147 strcpy(fh.codec,"MJPG");
148 fh.unpackedsize = 3*width*height;
149
150 rh.size = sizeof(lh1)+sizeof(ah)+sizeof(lh2)+sizeof(sh)+
151 sizeof(fh)+sizeof(lh3)+sizeof(dh)+sizeof(lh4)+
152 nframes*sizeof(struct db_head)+
153 totalsize + sizeof(struct idx1_head)+ (16*nframes) +4; // FIXME:16 bytes per nframe // the '4' - what for???
154
155 lh1.size = 4+sizeof(ah)+sizeof(lh2)+sizeof(sh)+sizeof(fh)+sizeof(lh3)+sizeof(dh);
156 ah.size = sizeof(ah)-8;
157 lh2.size = 4+sizeof(sh)+sizeof(fh)+sizeof(lh3)+sizeof(dh); //4+sizeof(sh)+sizeof(fh);
158 sh.size = sizeof(sh)-8;
159 fh.size = sizeof(fh)-8;
160 fh.size2 = fh.size;
161 lh3.size = 4+sizeof(dh);
162 lh4.size = 4+ nframes*sizeof(struct db_head)+ totalsize;
163
164 lseek(fd, 0, SEEK_SET);
165
166 write(fd, &rh, sizeof(rh));
167 write(fd, &lh1, sizeof(lh1));
168 write(fd, &ah, sizeof(ah));
169 write(fd, &lh2, sizeof(lh2));
170 write(fd, &sh, sizeof(sh));
171 write(fd, &fh, sizeof(fh));
172 write(fd, &lh3, sizeof(lh3));
173 write(fd, &dh, sizeof(dh));
174 write(fd, &lh4, sizeof(lh4));
175}
176
177
178/* NOTE: This is not a general purpose routine - it is meant to only
179 cope with AVIs saved using the other functions in this file
180void avi_explode(char *fname)
181{
182 struct riff_head rh;
183 struct list_head lh1;
184 struct avi_head ah;
185 struct list_head lh2;
186 struct stream_head sh;
187 struct frame_head fh;
188 struct list_head lh3;
189 int hsize, qsize;
190 u16 *htables = jpeg_huffman_tables(&hsize);
191 u16 *qtables = jpeg_quantisation_tables(&qsize, image_quality);
192 int fd, i;
193
194 fd = open(fname,O_RDONLY);
195 if (fd == -1) {
196 perror(fname);
197 return;
198 }
199
200 read(fd, &rh, sizeof(rh));
201 read(fd, &lh1, sizeof(lh1));
202 read(fd, &ah, sizeof(ah));
203 read(fd, &lh2, sizeof(lh2));
204 read(fd, &sh, sizeof(sh));
205 read(fd, &fh, sizeof(fh));
206 read(fd, &lh3, sizeof(lh3));
207
208 for (i=0; ; i++) {
209 u8 buf[500*1024];
210 struct db_head db;
211 char fname[100];
212 int fd2;
213
214 if (read(fd, &db, sizeof(db)) != sizeof(db) ||
215 read(fd, buf, db.size) != db.size) break;
216
217 snprintf(fname, sizeof(fname)-1,"frame.%d", i);
218
219 fd2 = open(fname,O_WRONLY|O_CREAT, 0644);
220 if (fd2 == -1) {
221 perror(fname);
222 continue;
223 }
224 write(fd2, buf, 2);
225 write(fd2, qtables, qsize);
226 write(fd2, htables, hsize);
227 write(fd2, buf+2, db.size-2);
228 close(fd2);
229 }
230 close(fd);
231 printf("exploded %d frames\n", i);
232}
233
234*/
235
diff --git a/noncore/multimedia/camera/avi.h b/noncore/multimedia/camera/avi.h
new file mode 100644
index 0000000..fbdc14a
--- a/dev/null
+++ b/noncore/multimedia/camera/avi.h
@@ -0,0 +1,142 @@
1/**********************************************************************
2** Copyright (C) 2003 Michael 'Mickey' Lauer. All rights reserved.
3** Based on work from Andrew Tridgell and the jpegtoavi project
4**
5** This file is part of Opie Environment.
6**
7** This file may be distributed and/or modified under the terms of the
8** GNU General Public License version 2 as published by the Free Software
9** Foundation and appearing in the file LICENSE.GPL included in the
10** packaging of this file.
11**
12** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
13** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
14**
15**********************************************************************/
16
17#ifndef AVI_H
18#define AVI_H
19
20#include <unistd.h>
21#include <stdio.h>
22#include <sys/types.h>
23
24#ifdef __cplusplus
25extern "C" {
26#endif
27
28typedef unsigned char u8;
29typedef unsigned short u16;
30typedef unsigned u32;
31
32// header flags
33
34const u32 AVIF_HASINDEX=0x00000010; /* index at end of file */
35const u32 AVIF_MUSTUSEINDEX=0x00000020;
36const u32 AVIF_ISINTERLEAVED=0x00000100;
37const u32 AVIF_TRUSTCKTYPE=0x00000800;
38const u32 AVIF_WASCAPTUREFILE=0x00010000;
39const u32 AVIF_COPYRIGHTED=0x00020000;
40
41// function prototypes
42
43void avi_start(int fd, int frame);
44void avi_add(int fd, u8 *buf, int size);
45void avi_end(int fd, int width, int height, int fps);
46void fprint_quartet(int fd, unsigned int i);
47
48// the following structures are ordered as they appear in a typical AVI
49
50struct riff_head {
51 char riff[4]; // chunk type = "RIFF"
52 u32 size; // chunk size
53 char avistr[4]; // avi magic = "AVI "
54};
55
56// the avih chunk contains a number of list chunks
57
58struct avi_head {
59 char avih[4]; // chunk type = "avih"
60 u32 size; // chunk size
61 u32 time; // microsec per frame == 1e6 / fps
62 u32 maxbytespersec; // = 1e6*(total size/frames)/per_usec)
63 u32 pad; // pad = 0
64 u32 flags; // e.g. AVIF_HASINDEX
65 u32 nframes; // total number of frames
66 u32 initialframes; // = 0
67 u32 numstreams; // = 1 for now (later = 2 because of audio)
68 u32 suggested_bufsize; // = 0 (no suggestion)
69 u32 width; // width
70 u32 height; // height
71 u32 reserved[4]; // reserved for future use = 0
72};
73
74
75// the LIST chunk contains a number (==#numstreams) of stream chunks
76
77struct list_head {
78 char list[4]; // chunk type = "LIST"
79 u32 size;
80 char type[4];
81};
82
83
84struct dmlh_head {
85 char dmlh[4]; // chunk type dmlh
86 u32 size; // 4
87 u32 nframes; // number of frames
88};
89
90
91struct stream_head {
92 char strh[4]; // chunk type = "strh"
93 u32 size; // chunk size
94 char vids[4]; // stream type = "vids"
95 char codec[4]; // codec name (for us, = "MJPG")
96 u32 flags; // contains AVIT_F* flags
97 u16 priority; // = 0
98 u16 language; // = 0
99 u32 initialframes; // = 0
100 u32 scale; // = usec per frame
101 u32 rate; // 1e6
102 u32 start; // = 0
103 u32 length; // number of frames
104 u32 suggested_bufsize; // = 0
105 u32 quality; // = 0 ?
106 u32 samplesize; // = 0 ?
107};
108
109
110struct db_head {
111 char db[4]; // "00db"
112 u32 size;
113};
114
115// a frame chunk contains one JPEG image
116
117struct frame_head {
118 char strf[4]; // chunk type = "strf"
119 u32 size; // sizeof chunk (big endian) ?
120 u32 size2; // sizeof chunk (little endian) ?
121 u32 width;
122 u32 height;
123 u16 planes; // 1 bitplane
124 u16 bitcount; // 24 bpl
125 char codec[4]; // MJPG (for us)
126 u32 unpackedsize; // = 3*w*h
127 u32 r1; // reserved
128 u32 r2; // reserved
129 u32 clr_used; // reserved
130 u32 clr_important; // reserved
131};
132
133struct idx1_head {
134 char idx1[4]; // chunk type = "idx1"
135 u32 size; // chunk size
136};
137
138#ifdef __cplusplus
139}
140#endif
141
142#endif
diff --git a/noncore/multimedia/camera/camera.pro b/noncore/multimedia/camera/camera.pro
index 8aedcea..c0e6ca8 100644
--- a/noncore/multimedia/camera/camera.pro
+++ b/noncore/multimedia/camera/camera.pro
@@ -1,25 +1,27 @@
1MOC_DIR = ./moc 1MOC_DIR = ./moc
2OBJECTS_DIR = ./obj 2OBJECTS_DIR = ./obj
3DESTDIR = $(OPIEDIR)/bin 3DESTDIR = $(OPIEDIR)/bin
4TEMPLATE = app 4TEMPLATE = app
5CONFIG = qt warn_on debug 5CONFIG = qt warn_on debug
6 6
7HEADERS = imageio.h \ 7HEADERS = avi.h \
8 imageio.h \
8 zcameraio.h \ 9 zcameraio.h \
9 previewwidget.h \ 10 previewwidget.h \
10 mainwindow.h 11 mainwindow.h
11 12
12SOURCES = imageio.cpp \ 13SOURCES = avi.c \
14 imageio.cpp \
13 zcameraio.cpp \ 15 zcameraio.cpp \
14 previewwidget.cpp \ 16 previewwidget.cpp \
15 mainwindow.cpp \ 17 mainwindow.cpp \
16 main.cpp 18 main.cpp
17 19
18INCLUDEPATH += $(OPIEDIR)/include 20INCLUDEPATH += $(OPIEDIR)/include
19DEPENDPATH += $(OPIEDIR)/include 21DEPENDPATH += $(OPIEDIR)/include
20LIBS += -lqpe -lopie -lopiecore2 22LIBS += -lqpe -lopie -lopiecore2
21INTERFACES = 23INTERFACES =
22TARGET = opiecam 24TARGET = opiecam
23 25
24include ( $(OPIEDIR)/include.pro ) 26include ( $(OPIEDIR)/include.pro )
25 27
diff --git a/noncore/multimedia/camera/mainwindow.cpp b/noncore/multimedia/camera/mainwindow.cpp
index 6141fd1..e27a50e 100644
--- a/noncore/multimedia/camera/mainwindow.cpp
+++ b/noncore/multimedia/camera/mainwindow.cpp
@@ -1,435 +1,551 @@
1/********************************************************************** 1/**********************************************************************
2** Copyright (C) 2002 Michael 'Mickey' Lauer. All rights reserved. 2** Copyright (C) 2002 Michael 'Mickey' Lauer. All rights reserved.
3** 3**
4** This file is part of Opie Environment. 4** This file is part of Opie Environment.
5** 5**
6** This file may be distributed and/or modified under the terms of the 6** This file may be distributed and/or modified under the terms of the
7** GNU General Public License version 2 as published by the Free Software 7** GNU General Public License version 2 as published by the Free Software
8** Foundation and appearing in the file LICENSE.GPL included in the 8** Foundation and appearing in the file LICENSE.GPL included in the
9** packaging of this file. 9** packaging of this file.
10** 10**
11** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE 11** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
12** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 12** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
13** 13**
14**********************************************************************/ 14**********************************************************************/
15 15
16#include "mainwindow.h" 16#include "mainwindow.h"
17#include "previewwidget.h" 17#include "previewwidget.h"
18#include "zcameraio.h" 18#include "zcameraio.h"
19#include "imageio.h" 19#include "imageio.h"
20#include "avi.h"
20 21
21#include <qapplication.h> 22#include <qapplication.h>
22#include <qaction.h> 23#include <qaction.h>
23#include <qvbox.h> 24#include <qvbox.h>
24#include <qcombobox.h> 25#include <qcombobox.h>
25#include <qcursor.h> 26#include <qcursor.h>
26#include <qdatastream.h> 27#include <qdatastream.h>
27#include <qfile.h> 28#include <qfile.h>
28#include <qimage.h> 29#include <qimage.h>
29#include <qlabel.h> 30#include <qlabel.h>
30#include <qpopupmenu.h> 31#include <qpopupmenu.h>
31#include <qprogressbar.h> 32#include <qprogressbar.h>
32#include <qpushbutton.h> 33#include <qpushbutton.h>
33#include <qmessagebox.h> 34#include <qmessagebox.h>
34#include <qlayout.h> 35#include <qlayout.h>
35#include <qdirectpainter_qws.h> 36#include <qdirectpainter_qws.h>
36#include <qpe/global.h> 37#include <qpe/global.h>
37#include <qpe/resource.h> 38#include <qpe/resource.h>
38#include <qpe/qcopenvelope_qws.h> 39#include <qpe/qcopenvelope_qws.h>
39#include <opie/ofiledialog.h> 40#include <opie/ofiledialog.h>
40#include <opie/odevice.h> 41#include <opie/odevice.h>
41using namespace Opie; 42using namespace Opie;
42#include <opie2/odebug.h> 43#include <opie2/odebug.h>
43 44
44#include <assert.h> 45#include <assert.h>
45#include <sys/types.h> 46#include <sys/types.h>
46#include <sys/stat.h> 47#include <sys/stat.h>
47#include <fcntl.h> 48#include <fcntl.h>
48#include <string.h> 49#include <string.h>
49#include <errno.h> 50#include <errno.h>
50#include <unistd.h> 51#include <unistd.h>
51 52
52#define CAPTUREFILE "/tmp/capture.dat" 53#define CAPTUREFILE "/tmp/capture.dat"
54#define OUTPUTFILE "/tmp/output.avi"
53 55
54CameraMainWindow::CameraMainWindow( QWidget * parent, const char * name, WFlags f ) 56CameraMainWindow::CameraMainWindow( QWidget * parent, const char * name, WFlags f )
55 :QMainWindow( parent, name, f ), _capturing( false ), _pics( 0 ) 57 :QMainWindow( parent, name, f ),
58 _rotation( 270 ), // FIXME: get this from current settings (ODevice?)
59 _capturing( false ),
60 _pics( 0 ), _videos( 0 )
56{ 61{
57 #ifdef QT_NO_DEBUG 62 #ifdef QT_NO_DEBUG
58 if ( !ZCameraIO::instance()->isOpen() ) 63 if ( !ZCameraIO::instance()->isOpen() )
59 { 64 {
60 QVBox* v = new QVBox( this ); 65 QVBox* v = new QVBox( this );
61 v->setMargin( 10 ); 66 v->setMargin( 10 );
62 QLabel* l1 = new QLabel( v ); 67 QLabel* l1 = new QLabel( v );
63 l1->setPixmap( Resource::loadPixmap( "camera/error" ) ); 68 l1->setPixmap( Resource::loadPixmap( "camera/error" ) );
64 QLabel* l2 = new QLabel( v ); 69 QLabel* l2 = new QLabel( v );
65 l2->setText( "<b>Sorry. could not detect your camera :-(</b><p>" 70 l2->setText( "<b>Sorry. could not detect your camera :-(</b><p>"
66 "* Is the sharpzdc_cs module loaded ?<br>" 71 "* Is the sharpzdc_cs module loaded ?<br>"
67 "* Is /dev/sharpzdc read/writable ?<p>" ); 72 "* Is /dev/sharpzdc read/writable ?<p>" );
68 connect( new QPushButton( "Exit", v ), SIGNAL( clicked() ), this, SLOT( close() ) ); 73 connect( new QPushButton( "Exit", v ), SIGNAL( clicked() ), this, SLOT( close() ) );
69 setCentralWidget( v ); 74 setCentralWidget( v );
70 return; 75 return;
71 } 76 }
72 #endif 77 #endif
73 78
74 init(); 79 init();
75 80
76 _rotation = 270; //TODO: grab these from the actual settings 81 _rotation = 270; //TODO: grab these from the actual settings
77 82
78 preview = new PreviewWidget( this, "camera preview widget" ); 83 preview = new PreviewWidget( this, "camera preview widget" );
79 //setCentralWidget( preview ); <--- don't do this! 84 //setCentralWidget( preview ); <--- don't do this!
80 preview->resize( QSize( 240, 288 ) ); 85 preview->resize( QSize( 240, 288 ) );
81 preview->show(); 86 preview->show();
82 87
83 // construct a System Channel to receive setRotation messages 88 // construct a System Channel to receive setRotation messages
84 _sysChannel = new QCopChannel( "QPE/System", this ); 89 _sysChannel = new QCopChannel( "QPE/System", this );
85 connect( _sysChannel, SIGNAL( received( const QCString&, const QByteArray& ) ), 90 connect( _sysChannel, SIGNAL( received( const QCString&, const QByteArray& ) ),
86 this, SLOT( systemMessage( const QCString&, const QByteArray& ) ) ); 91 this, SLOT( systemMessage( const QCString&, const QByteArray& ) ) );
87 92
88 connect( preview, SIGNAL( contextMenuRequested() ), this, SLOT( showContextMenu() ) ); 93 connect( preview, SIGNAL( contextMenuRequested() ), this, SLOT( showContextMenu() ) );
89 94
90 connect( ZCameraIO::instance(), SIGNAL( shutterClicked() ), this, SLOT( shutterClicked() ) ); 95 connect( ZCameraIO::instance(), SIGNAL( shutterClicked() ), this, SLOT( shutterClicked() ) );
91 96
92 updateCaption(); 97 updateCaption();
93 98
94}; 99};
95 100
96 101
97CameraMainWindow::~CameraMainWindow() 102CameraMainWindow::~CameraMainWindow()
98{ 103{
99} 104}
100 105
101 106
102void CameraMainWindow::init() 107void CameraMainWindow::init()
103{ 108{
104 // TODO: Save this stuff in config 109 // TODO: Save this stuff in config
105 flip = 'A'; // auto 110 flip = 'A'; // auto
106 quality = 50; 111 quality = 50;
107 zoom = 1; 112 zoom = 1;
108 captureX = 640; 113 captureX = 480;
109 captureY = 480; 114 captureY = 640;
110 captureFormat = "JPEG"; 115 captureFormat = "JPEG";
111 116
112 resog = new QActionGroup( 0, "reso", true ); 117 resog = new QActionGroup( 0, "reso", true );
113 resog->setToggleAction( true ); 118 resog->setToggleAction( true );
114 new QAction( " 64 x 48", 0, 0, resog, 0, true ); 119 new QAction( " 64 x 48", 0, 0, resog, 0, true );
115 new QAction( "128 x 96", 0, 0, resog, 0, true ); 120 new QAction( "128 x 96", 0, 0, resog, 0, true );
116 new QAction( "192 x 144", 0, 0, resog, 0, true ); 121 new QAction( "192 x 144", 0, 0, resog, 0, true );
117 new QAction( "256 x 192", 0, 0, resog, 0, true ); 122 new QAction( "256 x 192", 0, 0, resog, 0, true );
118 new QAction( "320 x 240", 0, 0, resog, 0, true ); 123 new QAction( "320 x 240", 0, 0, resog, 0, true );
119 new QAction( "384 x 288", 0, 0, resog, 0, true ); 124 new QAction( "384 x 288", 0, 0, resog, 0, true );
120 new QAction( "448 x 336", 0, 0, resog, 0, true ); 125 new QAction( "448 x 336", 0, 0, resog, 0, true );
121 new QAction( "512 x 384", 0, 0, resog, 0, true ); 126 new QAction( "512 x 384", 0, 0, resog, 0, true );
122 new QAction( "576 x 432", 0, 0, resog, 0, true ); 127 new QAction( "576 x 432", 0, 0, resog, 0, true );
123 ( new QAction( "640 x 480", 0, 0, resog, 0, true ) )->setOn( true ); 128 ( new QAction( "640 x 480", 0, 0, resog, 0, true ) )->setOn( true );
124 129
125 qualityg = new QActionGroup( 0, "quality", true ); 130 qualityg = new QActionGroup( 0, "quality", true );
126 qualityg->setToggleAction( true ); 131 qualityg->setToggleAction( true );
127 new QAction( " 0 (minimal)", 0, 0, qualityg, 0, true ); 132 new QAction( " 0 (minimal)", 0, 0, qualityg, 0, true );
128 new QAction( " 25 (low)", 0, 0, qualityg, 0, true ); 133 new QAction( " 25 (low)", 0, 0, qualityg, 0, true );
129 ( new QAction( " 50 (good)", 0, 0, qualityg, 0, true ) )->setOn( true ); 134 ( new QAction( " 50 (good)", 0, 0, qualityg, 0, true ) )->setOn( true );
130 new QAction( " 75 (better)", 0, 0, qualityg, 0, true ); 135 new QAction( " 75 (better)", 0, 0, qualityg, 0, true );
131 new QAction( "100 (best)", 0, 0, qualityg, 0, true ); 136 new QAction( "100 (best)", 0, 0, qualityg, 0, true );
132 137
133 zoomg = new QActionGroup( 0, "zoom", true ); 138 zoomg = new QActionGroup( 0, "zoom", true );
134 zoomg->setToggleAction( true ); 139 zoomg->setToggleAction( true );
135 ( new QAction( "x 1", 0, 0, zoomg, 0, true ) )->setOn( true ); 140 ( new QAction( "x 1", 0, 0, zoomg, 0, true ) )->setOn( true );
136 new QAction( "x 2", 0, 0, zoomg, 0, true ); 141 new QAction( "x 2", 0, 0, zoomg, 0, true );
137 142
138 flipg = new QActionGroup( 0, "flip", true ); 143 flipg = new QActionGroup( 0, "flip", true );
139 flipg->setToggleAction( true ); 144 flipg->setToggleAction( true );
140 ( new QAction( "Auto (recommended)", 0, 0, flipg, 0, true ) )->setOn( true ); 145 ( new QAction( "Auto (recommended)", 0, 0, flipg, 0, true ) )->setOn( true );
141 new QAction( "0 (always off)", 0, 0, flipg, 0, true ); 146 new QAction( "0 (always off)", 0, 0, flipg, 0, true );
142 new QAction( "X (always horizontal)", 0, 0, flipg, 0, true ); 147 new QAction( "X (always horizontal)", 0, 0, flipg, 0, true );
143 new QAction( "Y (always vertical)", 0, 0, flipg, 0, true ); 148 new QAction( "Y (always vertical)", 0, 0, flipg, 0, true );
144 new QAction( "* (always both)", 0, 0, flipg, 0, true ); 149 new QAction( "* (always both)", 0, 0, flipg, 0, true );
145 150
146 outputg = new QActionGroup( 0, "output", true ); 151 outputg = new QActionGroup( 0, "output", true );
147 outputg->setToggleAction( true ); 152 outputg->setToggleAction( true );
148 ( new QAction( "JPEG", 0, 0, outputg, 0, true ) )->setOn( true ); 153 ( new QAction( "JPEG", 0, 0, outputg, 0, true ) )->setOn( true );
149 new QAction( "PNG", 0, 0, outputg, 0, true ); 154 new QAction( "PNG", 0, 0, outputg, 0, true );
150 new QAction( "BMP", 0, 0, outputg, 0, true ); 155 new QAction( "BMP", 0, 0, outputg, 0, true );
151 new QAction( "AVI", 0, 0, outputg, 0, true ); 156 new QAction( "AVI", 0, 0, outputg, 0, true );
152 157
153 connect( resog, SIGNAL( selected(QAction*) ), this, SLOT( resoMenuItemClicked(QAction*) ) ); 158 connect( resog, SIGNAL( selected(QAction*) ), this, SLOT( resoMenuItemClicked(QAction*) ) );
154 connect( qualityg, SIGNAL( selected(QAction*) ), this, SLOT( qualityMenuItemClicked(QAction*) ) ); 159 connect( qualityg, SIGNAL( selected(QAction*) ), this, SLOT( qualityMenuItemClicked(QAction*) ) );
155 connect( zoomg, SIGNAL( selected(QAction*) ), this, SLOT( zoomMenuItemClicked(QAction*) ) ); 160 connect( zoomg, SIGNAL( selected(QAction*) ), this, SLOT( zoomMenuItemClicked(QAction*) ) );
156 connect( flipg, SIGNAL( selected(QAction*) ), this, SLOT( flipMenuItemClicked(QAction*) ) ); 161 connect( flipg, SIGNAL( selected(QAction*) ), this, SLOT( flipMenuItemClicked(QAction*) ) );
157 connect( outputg, SIGNAL( selected(QAction*) ), this, SLOT( outputMenuItemClicked(QAction*) ) ); 162 connect( outputg, SIGNAL( selected(QAction*) ), this, SLOT( outputMenuItemClicked(QAction*) ) );
158 163
159} 164}
160 165
161 166
162void CameraMainWindow::systemMessage( const QCString& msg, const QByteArray& data ) 167void CameraMainWindow::systemMessage( const QCString& msg, const QByteArray& data )
163{ 168{
169 int _newrotation;
170
164 QDataStream stream( data, IO_ReadOnly ); 171 QDataStream stream( data, IO_ReadOnly );
165 odebug << "received system message: " << msg << oendl; 172 odebug << "received system message: " << msg << oendl;
166 if ( msg == "setCurrentRotation(int)" ) 173 if ( msg == "setCurrentRotation(int)" )
167 { 174 {
168 stream >> _rotation; 175 stream >> _newrotation;
169 odebug << "received setCurrentRotation(" << _rotation << ")" << oendl; 176 odebug << "received setCurrentRotation(" << _newrotation << ")" << oendl;
170 177
171 switch ( _rotation ) 178 switch ( _newrotation )
172 { 179 {
173 case 270: preview->resize( QSize( 240, 288 ) ); break; 180 case 270: preview->resize( QSize( 240, 288 ) ); break;
174 case 180: preview->resize( QSize( 320, 208 ) ); break; 181 case 180: preview->resize( QSize( 320, 208 ) ); break;
175 default: QMessageBox::warning( this, "opie-camera", 182 default: QMessageBox::warning( this, "opie-camera",
176 "This rotation is not supported.\n" 183 "This rotation is not supported.\n"
177 "Supported are 180° and 270°" ); 184 "Supported are 180° and 270°" );
178 } 185 }
186
187 if ( _newrotation != _rotation )
188 {
189 int tmp = captureX;
190 captureX = captureY;
191 captureY = tmp;
192 _rotation = _newrotation;
193 }
194
195 updateCaption();
196
179 } 197 }
180} 198}
181 199
182 200
183void CameraMainWindow::changeZoom( int zoom ) 201void CameraMainWindow::changeZoom( int zoom )
184{ 202{
185 int z; 203 int z;
186 switch ( zoom ) 204 switch ( zoom )
187 { 205 {
188 case 0: z = 128; break; 206 case 0: z = 128; break;
189 case 1: z = 256; break; 207 case 1: z = 256; break;
190 case 2: z = 512; break; 208 case 2: z = 512; break;
191 default: assert( 0 ); break; 209 default: assert( 0 ); break;
192 } 210 }
193 211
194 ZCameraIO::instance()->setCaptureFrame( 240, 160, z ); 212 ZCameraIO::instance()->setCaptureFrame( 240, 160, z );
195} 213}
196 214
197 215
198void CameraMainWindow::showContextMenu() 216void CameraMainWindow::showContextMenu()
199{ 217{
200 QPopupMenu reso; 218 QPopupMenu reso;
201 reso.setCheckable( true ); 219 reso.setCheckable( true );
202 resog->addTo( &reso ); 220 resog->addTo( &reso );
203 221
204 QPopupMenu quality; 222 QPopupMenu quality;
205 quality.setCheckable( true ); 223 quality.setCheckable( true );
206 qualityg->addTo( &quality ); 224 qualityg->addTo( &quality );
207 225
208 QPopupMenu flip; 226 QPopupMenu flip;
209 flip.setCheckable( true ); 227 flip.setCheckable( true );
210 flipg->addTo( &flip ); 228 flipg->addTo( &flip );
211 229
212 QPopupMenu zoom; 230 QPopupMenu zoom;
213 zoom.setCheckable( true ); 231 zoom.setCheckable( true );
214 zoomg->addTo( &zoom ); 232 zoomg->addTo( &zoom );
215 233
216 QPopupMenu output; 234 QPopupMenu output;
217 output.setCheckable( true ); 235 output.setCheckable( true );
218 outputg->addTo( &output ); 236 outputg->addTo( &output );
219 237
220 QPopupMenu m( this ); 238 QPopupMenu m( this );
221 m.insertItem( "&Resolution", &reso ); 239 m.insertItem( "&Resolution", &reso );
222 m.insertItem( "&Zoom", &zoom ); 240 m.insertItem( "&Zoom", &zoom );
223 m.insertItem( "&Flip", &flip ); 241 m.insertItem( "&Flip", &flip );
224 m.insertItem( "&Quality", &quality ); 242 m.insertItem( "&Quality", &quality );
225 m.insertItem( "&Output As", &output ); 243 m.insertItem( "&Output As", &output );
244
245 #ifndef QT_NO_DEBUG
246 m.insertItem( "&Debug!", this, SLOT( doSomething() ) );
247 #endif
248
226 m.exec( QCursor::pos() ); 249 m.exec( QCursor::pos() );
227} 250}
228 251
229 252
230void CameraMainWindow::resoMenuItemClicked( QAction* a ) 253void CameraMainWindow::resoMenuItemClicked( QAction* a )
231{ 254{
232 captureX = a->text().left(3).toInt(); 255 switch ( _rotation )
233 captureY = a->text().right(3).toInt(); 256 {
257 case 270:
258 captureY = a->text().left(3).toInt();
259 captureX = a->text().right(3).toInt();
260 break;
261 case 180:
262 captureX = a->text().left(3).toInt();
263 captureY = a->text().right(3).toInt();
264 break;
265 default: QMessageBox::warning( this, "opie-camera",
266 "This rotation is not supported.\n"
267 "Supported are 180° and 270°" );
268 }
234 odebug << "Capture Resolution now: " << captureX << ", " << captureY << oendl; 269 odebug << "Capture Resolution now: " << captureX << ", " << captureY << oendl;
235 updateCaption(); 270 updateCaption();
236} 271}
237 272
238 273
239void CameraMainWindow::qualityMenuItemClicked( QAction* a ) 274void CameraMainWindow::qualityMenuItemClicked( QAction* a )
240{ 275{
241 quality = a->text().left(3).toInt(); 276 quality = a->text().left(3).toInt();
242 odebug << "Quality now: " << quality << oendl; 277 odebug << "Quality now: " << quality << oendl;
243 updateCaption(); 278 updateCaption();
244} 279}
245 280
246 281
247void CameraMainWindow::zoomMenuItemClicked( QAction* a ) 282void CameraMainWindow::zoomMenuItemClicked( QAction* a )
248{ 283{
249 zoom = QString( a->text().at(2) ).toInt(); 284 zoom = QString( a->text().at(2) ).toInt();
250 odebug << "Zoom now: " << zoom << oendl; 285 odebug << "Zoom now: " << zoom << oendl;
251 ZCameraIO::instance()->setZoom( zoom ); 286 ZCameraIO::instance()->setZoom( zoom );
252 updateCaption(); 287 updateCaption();
253} 288}
254 289
255 290
256void CameraMainWindow::flipMenuItemClicked( QAction* a ) 291void CameraMainWindow::flipMenuItemClicked( QAction* a )
257{ 292{
258 flip = QString( a->text().at(0) ); 293 flip = QString( a->text().at(0) );
259 odebug << "Flip now: " << flip << oendl; 294 odebug << "Flip now: " << flip << oendl;
260 if ( flip == "A" ) 295 if ( flip == "A" )
261 ZCameraIO::instance()->setFlip( ZCameraIO::AUTOMATICFLIP ); 296 ZCameraIO::instance()->setFlip( ZCameraIO::AUTOMATICFLIP );
262 else if ( flip == "0" ) 297 else if ( flip == "0" )
263 ZCameraIO::instance()->setFlip( ZCameraIO::XNOFLIP | ZCameraIO::YNOFLIP ); 298 ZCameraIO::instance()->setFlip( ZCameraIO::XNOFLIP | ZCameraIO::YNOFLIP );
264 else if ( flip == "X" ) 299 else if ( flip == "X" )
265 ZCameraIO::instance()->setFlip( ZCameraIO::XFLIP ); 300 ZCameraIO::instance()->setFlip( ZCameraIO::XFLIP );
266 else if ( flip == "Y" ) 301 else if ( flip == "Y" )
267 ZCameraIO::instance()->setFlip( ZCameraIO::YFLIP ); 302 ZCameraIO::instance()->setFlip( ZCameraIO::YFLIP );
268 else if ( flip == "*" ) 303 else if ( flip == "*" )
269 ZCameraIO::instance()->setFlip( ZCameraIO::XFLIP | ZCameraIO::YFLIP ); 304 ZCameraIO::instance()->setFlip( ZCameraIO::XFLIP | ZCameraIO::YFLIP );
270 305
271 updateCaption(); 306 updateCaption();
272} 307}
273 308
274 309
275void CameraMainWindow::outputMenuItemClicked( QAction* a ) 310void CameraMainWindow::outputMenuItemClicked( QAction* a )
276{ 311{
277 captureFormat = a->text(); 312 captureFormat = a->text();
278 odebug << "Output format now: " << captureFormat << oendl; 313 odebug << "Output format now: " << captureFormat << oendl;
279 updateCaption(); 314 updateCaption();
280} 315}
281 316
282 317
283void CameraMainWindow::shutterClicked() 318void CameraMainWindow::shutterClicked()
284{ 319{
285 if ( captureFormat != "AVI" ) // capture one photo per shutterClick 320 if ( captureFormat != "AVI" ) // capture one photo per shutterClick
286 { 321 {
287 Global::statusMessage( "CAPTURING..." ); 322 Global::statusMessage( "CAPTURING..." );
288 qApp->processEvents(); 323 qApp->processEvents();
289 324
290 odebug << "Shutter has been pressed" << oendl; 325 odebug << "Shutter has been pressed" << oendl;
291 ODevice::inst()->touchSound(); 326 ODevice::inst()->touchSound();
292 327
293 performCapture( captureFormat ); 328 performCapture( captureFormat );
294 } 329 }
295 else // capture video! start with one shutter click and stop with the next 330 else // capture video! start with one shutter click and stop with the next
296 { 331 {
297 !_capturing ? startVideoCapture() : stopVideoCapture(); 332 !_capturing ? startVideoCapture() : stopVideoCapture();
298 } 333 }
299} 334}
300 335
301 336
302void CameraMainWindow::performCapture( const QString& format ) 337void CameraMainWindow::performCapture( const QString& format )
303{ 338{
304 QString name; 339 QString name;
305 name.sprintf( "/tmp/image-%d_%d_%d_q%d.%s", _pics++, captureX, captureY, quality, (const char*) captureFormat.lower() ); 340 name.sprintf( "/tmp/image-%d_%d_%d_q%d.%s", _pics++, captureX, captureY, quality, (const char*) captureFormat.lower() );
306 QImage i; 341 QImage i;
307 ZCameraIO::instance()->captureFrame( captureX, captureY, zoom, &i ); 342 ZCameraIO::instance()->captureFrame( captureX, captureY, zoom, &i );
308 QImage im = i.convertDepth( 32 ); 343 QImage im = i.convertDepth( 32 );
309 bool result = im.save( name, format, quality ); 344 bool result = im.save( name, format, quality );
310 if ( !result ) 345 if ( !result )
311 { 346 {
312 oerr << "imageio-Problem while writing." << oendl; 347 oerr << "imageio-Problem while writing." << oendl;
313 Global::statusMessage( "Error!" ); 348 Global::statusMessage( "Error!" );
314 } 349 }
315 else 350 else
316 { 351 {
317 odebug << captureFormat << "-image has been successfully captured" << oendl; 352 odebug << captureFormat << "-image has been successfully captured" << oendl;
318 Global::statusMessage( "Ok." ); 353 Global::statusMessage( "Ok." );
319 } 354 }
320} 355}
321 356
322 357
323void CameraMainWindow::startVideoCapture() 358void CameraMainWindow::startVideoCapture()
324{ 359{
325 //ODevice::inst()->touchSound(); 360 //ODevice::inst()->touchSound();
326 ODevice::inst()->setLedState( Led_Mail, Led_BlinkSlow ); 361 ODevice::inst()->setLedState( Led_Mail, Led_BlinkSlow );
327 362
328 _capturefd = ::open( CAPTUREFILE, O_WRONLY | O_CREAT ); 363 _capturefd = ::open( CAPTUREFILE, O_WRONLY | O_CREAT | O_TRUNC );
329 if ( _capturefd == -1 ) 364 if ( _capturefd == -1 )
330 { 365 {
331 owarn << "can't open capture file: " << strerror(errno) << oendl; 366 owarn << "can't open capture file: " << strerror(errno) << oendl;
332 return; 367 return;
333 } 368 }
334 369
335 _capturebuf = new unsigned char[captureX*captureY*2]; 370 _capturebuf = new unsigned char[captureX*captureY*2];
336 _capturing = true; 371 _capturing = true;
337 _videopics = 0; 372 _videopics = 0;
373 _framerate = 0;
338 updateCaption(); 374 updateCaption();
339 _time.start(); 375 _time.start();
340 preview->setRefreshingRate( 1000 ); 376 preview->setRefreshingRate( 1000 );
341 startTimer( 100 ); // too fast but that is ok 377 startTimer( 100 ); // too fast but that is ok
342} 378}
343 379
344 380
345void CameraMainWindow::timerEvent( QTimerEvent* ) 381void CameraMainWindow::timerEvent( QTimerEvent* )
346{ 382{
347 if ( !_capturing ) 383 if ( !_capturing )
348 { 384 {
349 owarn << "timer event in CameraMainWindow without capturing video ?" << oendl; 385 odebug << "timer event in CameraMainWindow without capturing video ?" << oendl;
350 return; 386 return;
351 } 387 }
352 388
389 odebug << "timer event during video - now capturing frame #" << _videopics+1 << oendl;
390
353 ZCameraIO::instance()->captureFrame( captureX, captureY, zoom, _capturebuf ); 391 ZCameraIO::instance()->captureFrame( captureX, captureY, zoom, _capturebuf );
354 _videopics++; 392 _videopics++;
355 ::write( _capturefd, _capturebuf, captureX*captureY*2 ); 393 ::write( _capturefd, _capturebuf, captureX*captureY*2 );
356 setCaption( QString().sprintf( "Capturing %dx%d @ %.2f fps %d", 394 setCaption( QString().sprintf( "Capturing %dx%d @ %.2f fps %d",
357 captureX, captureY, 1000.0 / (_time.elapsed()/_videopics), _videopics ) ); 395 captureX, captureY, 1000.0 / (_time.elapsed()/_videopics), _videopics ) );
358} 396}
359 397
360 398
361void CameraMainWindow::stopVideoCapture() 399void CameraMainWindow::stopVideoCapture()
362{ 400{
363 killTimers(); 401 killTimers();
364 //ODevice::inst()->touchSound(); 402 //ODevice::inst()->touchSound();
365 ODevice::inst()->setLedState( Led_Mail, Led_Off ); 403 ODevice::inst()->setLedState( Led_Mail, Led_Off );
366 _capturing = false; 404 _capturing = false;
367 updateCaption(); 405 updateCaption();
368 ::close( _capturefd ); 406 ::close( _capturefd );
407 _framerate = 1000.0 / (_time.elapsed()/_videopics);
369 408
370 //postProcessVideo(); 409 postProcessVideo( CAPTUREFILE, QString().sprintf( "/tmp/video-%d_%d_%d_q%d-%dfps.avi", _videos++, captureX, captureY, quality, _framerate ) );
371 410
372 #ifndef QT_NO_DEBUG 411 #ifndef QT_NO_DEBUG
373 preview->setRefreshingRate( 1500 ); 412 preview->setRefreshingRate( 1500 );
374 #else 413 #else
375 preview->setRefreshingRate( 200 ); 414 preview->setRefreshingRate( 200 );
376 #endif 415 #endif
377 416
378 //delete[] _capturebuf; //FIXME: close memory leak 417 //delete[] _capturebuf; //FIXME: close memory leak
379} 418}
380 419
381void CameraMainWindow::postProcessVideo() 420void CameraMainWindow::postProcessVideo( const QString& infile, const QString& outfile )
382{ 421{
383 preview->setRefreshingRate( 0 ); 422 preview->setRefreshingRate( 0 );
384 423
385 /* 424 /*
425 unsigned char buf[153600];
386 426
387 QDialog* fr = new QDialog( this, "splash" ); //, false, QWidget::WStyle_NoBorder | QWidget::WStyle_Customize ); 427 int fd = ::open( "/var/compile/opie/noncore/multimedia/camera/capture-320x240.dat", O_RDONLY );
428 ::read( fd, &buf, 153600 );
429 QImage i;
430 bufferToImage( 240, 320, (unsigned char*) &buf, &i );
431 QPixmap p;
432 p.convertFromImage( i );
433 preview->setPixmap( p );
434 imageToFile( &i, "/tmp/tmpfile", "JPEG", 100 );
435 return;
436 */
437
438 QDialog* fr = new QDialog( this, "splash", false, QWidget::WStyle_StaysOnTop ); //, false, QWidget::WStyle_NoBorder | QWidget::WStyle_Customize );
388 fr->setCaption( "Please wait..." ); 439 fr->setCaption( "Please wait..." );
389 QVBoxLayout* box = new QVBoxLayout( fr, 2, 2 ); 440 QVBoxLayout* box = new QVBoxLayout( fr, 2, 2 );
390 QProgressBar* bar = new QProgressBar( fr ); 441 QProgressBar* bar = new QProgressBar( fr );
391 bar->setCenterIndicator( true ); 442 bar->setCenterIndicator( true );
392 bar->setTotalSteps( _videopics-1 ); 443 bar->setTotalSteps( _videopics-1 );
393 QLabel* label = new QLabel( "Post processing frame bla/bla", fr ); 444 QLabel* label = new QLabel( "Post processing frame bla/bla", fr );
394 box->addWidget( bar ); 445 box->addWidget( bar );
395 box->addWidget( label ); 446 box->addWidget( label );
396 fr->show(); 447 fr->show();
448 label->show();
449 bar->show();
450 fr->repaint();
397 qApp->processEvents(); 451 qApp->processEvents();
398 452
399 for ( int i = 0; i < _videopics; ++i ) 453 // open files
400 {
401 label->setText( QString().sprintf( "Post processing frame %d / %d", i+1, _videopics ) );
402 bar->setProgress( i );
403 qApp->processEvents();
404 }
405
406 */
407 454
408 int infd = ::open( CAPTUREFILE, O_RDONLY ); 455 int infd = ::open( (const char*) infile, O_RDONLY );
409 if ( infd == -1 ) 456 if ( infd == -1 )
410 { 457 {
411 owarn << "couldn't open capture file: " << strerror(errno) << oendl; 458 owarn << "couldn't open capture file: " << strerror(errno) << oendl;
412 return; 459 return;
413 } 460 }
414 461
415 int outfd = ::open( "/tmp/output.avi", O_WRONLY ); 462 int outfd = ::open( (const char*) outfile, O_CREAT | O_WRONLY | O_TRUNC, 0644 );
416 if ( outfd == -1 ) 463 if ( outfd == -1 )
417 { 464 {
418 owarn << "couldn't open output file: " << strerror(errno) << oendl; 465 owarn << "couldn't open output file: " << strerror(errno) << oendl;
419 return; 466 return;
420 } 467 }
421 468
469 int framesize = captureX*captureY*2;
470
471 unsigned char* inbuffer = new unsigned char[ framesize ];
472 QImage image;
422 473
474 avi_start( outfd, _videopics ); // write preambel
423 475
476 // post process
477
478 for ( int i = 0; i < _videopics; ++i )
479 {
480 odebug << "processing frame " << i << oendl;
481
482 // <gui>
483 label->setText( QString().sprintf( "Post processing frame %d / %d", i+1, _videopics ) );
484 bar->setProgress( i );
485 bar->repaint();
486 qApp->processEvents();
487 // </gui>
488
489 int read = ::read( infd, inbuffer, framesize );
490 odebug << "read " << read << " bytes" << oendl;
491 bufferToImage( captureX, captureY, inbuffer, &image );
492
493 QPixmap p;
494 p.convertFromImage( image );
495 preview->setPixmap( p );
496 preview->repaint();
497 qApp->processEvents();
498
499 QString tmpfilename( "/tmp/tempfile" );
500 //tmpfilename.sprintf( "/tmp/test/%d.jpg", i );
501
502 imageToFile( &image, tmpfilename, "JPEG", quality );
503
504 QFile framefile( tmpfilename );
505 if ( !framefile.open( IO_ReadOnly ) )
506 {
507 oerr << "can't process file: %s" << strerror(errno) << oendl;
508 return; // TODO: clean up temp ressources
509 }
510
511 int filesize = framefile.size();
512 odebug << "filesize for frame " << i << " = " << filesize << oendl;
513
514 unsigned char* tempbuffer = new unsigned char[ filesize ];
515 framefile.readBlock( (char*) tempbuffer, filesize );
516 avi_add( outfd, tempbuffer, filesize );
517 delete tempbuffer;
518 framefile.close();
519 }
520
521 avi_end( outfd, captureX, captureY, _framerate );
522
523 fr->hide();
524 delete fr;
525
526 updateCaption();
424 527
425} 528}
426 529
530
427void CameraMainWindow::updateCaption() 531void CameraMainWindow::updateCaption()
428{ 532{
429 if ( !_capturing ) 533 if ( !_capturing )
430 setCaption( QString().sprintf( "Opie-Camera: %dx%d %s q%d z%d (%s)", captureX, captureY, (const char*) captureFormat.lower(), quality, zoom, (const char*) flip ) ); 534 setCaption( QString().sprintf( "Opie-Camera: %dx%d %s q%d z%d (%s)", captureX, captureY, (const char*) captureFormat.lower(), quality, zoom, (const char*) flip ) );
431 else 535 else
432 setCaption( "Opie-Camera: => CAPTURING <=" ); 536 setCaption( "Opie-Camera: => CAPTURING <=" );
433} 537}
434 538
435 539
540#ifndef QT_NO_DEBUG
541void CameraMainWindow::doSomething()
542{
543 captureX = 240;
544 captureY = 320;
545 _videopics = 176;
546 _framerate = 5;
547 postProcessVideo( "/var/compile/opie/noncore/multimedia/camera/capture-320x240.dat",
548 "/tmp/output.avi" );
549}
550#endif
551
diff --git a/noncore/multimedia/camera/mainwindow.h b/noncore/multimedia/camera/mainwindow.h
index ad8d1b1..ac83488 100644
--- a/noncore/multimedia/camera/mainwindow.h
+++ b/noncore/multimedia/camera/mainwindow.h
@@ -1,92 +1,99 @@
1/********************************************************************** 1/**********************************************************************
2** Copyright (C) 2003 Michael 'Mickey' Lauer. All rights reserved. 2** Copyright (C) 2003 Michael 'Mickey' Lauer. All rights reserved.
3** 3**
4** This file is part of Opie Environment. 4** This file is part of Opie Environment.
5** 5**
6** This file may be distributed and/or modified under the terms of the 6** This file may be distributed and/or modified under the terms of the
7** GNU General Public License version 2 as published by the Free Software 7** GNU General Public License version 2 as published by the Free Software
8** Foundation and appearing in the file LICENSE.GPL included in the 8** Foundation and appearing in the file LICENSE.GPL included in the
9** packaging of this file. 9** packaging of this file.
10** 10**
11** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE 11** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
12** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 12** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
13** 13**
14**********************************************************************/ 14**********************************************************************/
15 15
16#ifndef MAINWINDOW_H 16#ifndef MAINWINDOW_H
17#define MAINWINDOW_H 17#define MAINWINDOW_H
18 18
19#include <qmainwindow.h> 19#include <qmainwindow.h>
20#include <qdatetime.h> 20#include <qdatetime.h>
21#include <qimage.h> 21#include <qimage.h>
22#include <qpixmap.h> 22#include <qpixmap.h>
23#include <qdatetime.h> 23#include <qdatetime.h>
24 24
25class QAction; 25class QAction;
26class QActionGroup; 26class QActionGroup;
27class QIconSet; 27class QIconSet;
28class QTimerEvent; 28class QTimerEvent;
29class QToolButton; 29class QToolButton;
30class QLabel; 30class QLabel;
31class MainWindowBase; 31class MainWindowBase;
32class QCopChannel; 32class QCopChannel;
33class PreviewWidget; 33class PreviewWidget;
34 34
35class CameraMainWindow: public QMainWindow 35class CameraMainWindow: public QMainWindow
36{ 36{
37 Q_OBJECT 37 Q_OBJECT
38 38
39 public: 39 public:
40 CameraMainWindow( QWidget * parent = 0, const char * name = "mainwindow", WFlags f = 0 ); 40 CameraMainWindow( QWidget * parent = 0, const char * name = "mainwindow", WFlags f = 0 );
41 virtual ~CameraMainWindow(); 41 virtual ~CameraMainWindow();
42 42
43 public slots: 43 public slots:
44 void changeZoom( int ); 44 void changeZoom( int );
45 void systemMessage( const QCString&, const QByteArray& ); 45 void systemMessage( const QCString&, const QByteArray& );
46 void showContextMenu(); 46 void showContextMenu();
47 void resoMenuItemClicked( QAction* ); 47 void resoMenuItemClicked( QAction* );
48 void qualityMenuItemClicked( QAction* ); 48 void qualityMenuItemClicked( QAction* );
49 void zoomMenuItemClicked( QAction* ); 49 void zoomMenuItemClicked( QAction* );
50 void flipMenuItemClicked( QAction* ); 50 void flipMenuItemClicked( QAction* );
51 void outputMenuItemClicked( QAction* ); 51 void outputMenuItemClicked( QAction* );
52 void shutterClicked(); 52 void shutterClicked();
53 53
54 void updateCaption(); 54 void updateCaption();
55 55
56 protected: 56 protected:
57 void init(); 57 void init();
58 void startVideoCapture(); 58 void startVideoCapture();
59 void stopVideoCapture(); 59 void stopVideoCapture();
60 void postProcessVideo(); 60 void postProcessVideo( const QString&, const QString& );
61 void performCapture( const QString& ); 61 void performCapture( const QString& );
62 62
63 virtual void timerEvent( QTimerEvent* ); 63 virtual void timerEvent( QTimerEvent* );
64 64
65 protected slots:
66 #ifndef QT_NO_DEBUG
67 void doSomething(); // solely for debugging purposes
68 #endif
69
65 private: 70 private:
66 PreviewWidget* preview; 71 PreviewWidget* preview;
67 int _rotation; 72 int _rotation;
68 QCopChannel* _sysChannel; 73 QCopChannel* _sysChannel;
69 74
70 QActionGroup* resog; 75 QActionGroup* resog;
71 QActionGroup* qualityg; 76 QActionGroup* qualityg;
72 QActionGroup* zoomg; 77 QActionGroup* zoomg;
73 QActionGroup* flipg; 78 QActionGroup* flipg;
74 QActionGroup* outputg; 79 QActionGroup* outputg;
75 80
76 QString flip; 81 QString flip;
77 int quality; 82 int quality;
78 int zoom; 83 int zoom;
79 int captureX; 84 int captureX;
80 int captureY; 85 int captureY;
81 QString captureFormat; 86 QString captureFormat;
82 87
83 bool _capturing; 88 bool _capturing;
84 int _pics; 89 int _pics;
90 int _videos;
85 91
86 QTime _time; 92 QTime _time;
87 int _videopics; 93 int _videopics;
88 int _capturefd; 94 int _capturefd;
95 int _framerate;
89 unsigned char* _capturebuf; 96 unsigned char* _capturebuf;
90}; 97};
91 98
92#endif 99#endif
diff --git a/noncore/multimedia/camera/zcameraio.cpp b/noncore/multimedia/camera/zcameraio.cpp
index 1c449e7..c940b45 100644
--- a/noncore/multimedia/camera/zcameraio.cpp
+++ b/noncore/multimedia/camera/zcameraio.cpp
@@ -168,151 +168,144 @@ void ZCameraIO::setReadMode( int mode )
168void ZCameraIO::setFlip( int flip ) 168void ZCameraIO::setFlip( int flip )
169{ 169{
170 _flip = flip; 170 _flip = flip;
171} 171}
172 172
173 173
174void ZCameraIO::clearShutterLatch() 174void ZCameraIO::clearShutterLatch()
175{ 175{
176 write( "B", 1 ); 176 write( "B", 1 );
177} 177}
178 178
179 179
180bool ZCameraIO::read( char* b, int len ) 180bool ZCameraIO::read( char* b, int len )
181{ 181{
182 #ifndef NO_TIMING 182 #ifndef NO_TIMING
183 QTime t; 183 QTime t;
184 t.start(); 184 t.start();
185 #endif 185 #endif
186 int rlen = ::read( _driver, b, len ); 186 int rlen = ::read( _driver, b, len );
187 #ifndef NO_TIMING 187 #ifndef NO_TIMING
188 int time = t.elapsed(); 188 int time = t.elapsed();
189 #else 189 #else
190 int time = -1; 190 int time = -1;
191 #endif 191 #endif
192 if ( rlen ) 192 if ( rlen )
193 odebug << "read " << rlen << " ('" << b[0] << b[1] << b[2] << b[3] << "') [" << time << " ms] from driver." << oendl; 193 odebug << "read " << rlen << " ('" << b[0] << b[1] << b[2] << b[3] << "') [" << time << " ms] from driver." << oendl;
194 else 194 else
195 odebug << "read nothing from driver." << oendl; 195 odebug << "read nothing from driver." << oendl;
196 return rlen == len; 196 return rlen == len;
197} 197}
198 198
199 199
200bool ZCameraIO::write( char* buf, int len ) 200bool ZCameraIO::write( char* buf, int len )
201{ 201{
202 if ( !len ) 202 if ( !len )
203 len = strlen( buf ); 203 len = strlen( buf );
204 204
205 odebug << "writing '" << buf << "' to driver." << oendl; 205 odebug << "writing '" << buf << "' to driver." << oendl;
206 206
207 return ::write( _driver, buf, len ) == len; 207 return ::write( _driver, buf, len ) == len;
208} 208}
209 209
210 210
211bool ZCameraIO::snapshot( QImage* image ) 211bool ZCameraIO::snapshot( QImage* image )
212{ 212{
213 setReadMode( STATUS ); 213 setReadMode( STATUS );
214 214
215 odebug << "finder reversed = " << isFinderReversed() << oendl; 215 odebug << "finder reversed = " << isFinderReversed() << oendl;
216 odebug << "rotation = " << _rot << oendl; 216 odebug << "rotation = " << _rot << oendl;
217 217
218 int readmode; 218 int readmode;
219 if ( _flip == -1 ) // AUTO 219 if ( _flip == -1 ) // AUTO
220 { 220 {
221 if ( _rot ) // Portrait 221 if ( _rot ) // Portrait
222 { 222 {
223 readmode = IMAGE | isFinderReversed() ? XFLIP | YFLIP : 0; 223 readmode = IMAGE | isFinderReversed() ? XFLIP | YFLIP : 0;
224 } 224 }
225 else // Landscape 225 else // Landscape
226 { 226 {
227 readmode = IMAGE | XFLIP | YFLIP; 227 readmode = IMAGE | XFLIP | YFLIP;
228 } 228 }
229 } 229 }
230 else // OVERRIDE 230 else // OVERRIDE
231 { 231 {
232 readmode = IMAGE | _flip; 232 readmode = IMAGE | _flip;
233 } 233 }
234 234
235 setReadMode( readmode ); 235 setReadMode( readmode );
236 236
237 char buf[_readlen]; 237 char buf[_readlen];
238 char* bp = buf; 238 char* bp = buf;
239 unsigned char* p; 239 unsigned char* p;
240 240
241 read( bp, _readlen ); 241 read( bp, _readlen );
242 242
243 image->create( _width, _height, 16 ); 243 image->create( _width, _height, 16 );
244 for ( int i = 0; i < _height; ++i ) 244 for ( int i = 0; i < _height; ++i )
245 { 245 {
246 p = image->scanLine( i ); 246 p = image->scanLine( i );
247 for ( int j = 0; j < _width; j++ ) 247 for ( int j = 0; j < _width; j++ )
248 { 248 {
249 *p = *bp; 249 *p = *bp;
250 p++; 250 p++;
251 bp++; 251 bp++;
252 *p = *bp; 252 *p = *bp;
253 p++; 253 p++;
254 bp++; 254 bp++;
255 } 255 }
256 } 256 }
257 257
258 return true; 258 return true;
259} 259}
260 260
261 261
262bool ZCameraIO::snapshot( unsigned char* buf ) 262bool ZCameraIO::snapshot( unsigned char* buf )
263{ 263{
264 setReadMode( STATUS ); 264 setReadMode( STATUS );
265 265
266 odebug << "finder reversed = " << isFinderReversed() << oendl; 266 odebug << "finder reversed = " << isFinderReversed() << oendl;
267 odebug << "rotation = " << _rot << oendl; 267 odebug << "rotation = " << _rot << oendl;
268 268
269 int readmode; 269 int readmode;
270 if ( _flip == -1 ) // AUTO 270 if ( _flip == -1 ) // AUTO
271 { 271 {
272 if ( _rot ) // Portrait 272 if ( _rot ) // Portrait
273 { 273 {
274 readmode = IMAGE | isFinderReversed() ? XFLIP | YFLIP : 0; 274 readmode = IMAGE | isFinderReversed() ? XFLIP | YFLIP : 0;
275 } 275 }
276 else // Landscape 276 else // Landscape
277 { 277 {
278 readmode = IMAGE | XFLIP | YFLIP; 278 readmode = IMAGE | XFLIP | YFLIP;
279 } 279 }
280 } 280 }
281 else // OVERRIDE 281 else // OVERRIDE
282 { 282 {
283 readmode = IMAGE | _flip; 283 readmode = IMAGE | _flip;
284 } 284 }
285 285
286 setReadMode( readmode ); 286 setReadMode( readmode );
287 read( (char*) buf, _readlen ); 287 read( (char*) buf, _readlen );
288 288
289} 289}
290 290
291 291
292void ZCameraIO::captureFrame( int w, int h, int zoom, QImage* image ) 292void ZCameraIO::captureFrame( int w, int h, int zoom, QImage* image )
293{ 293{
294 int pw = _width; 294 int pw = _width;
295 int ph = _height; 295 int ph = _height;
296 if ( _rot ) 296 setCaptureFrame( w, h, zoom*256, _rot );
297 setCaptureFrame( h, w, zoom*256, true );
298 else
299 setCaptureFrame( w, h, zoom*256, false );
300 snapshot( image ); 297 snapshot( image );
301 setCaptureFrame( pw, ph, _zoom, _rot ); 298 setCaptureFrame( pw, ph, _zoom, _rot );
302} 299}
303 300
304 301
305void ZCameraIO::captureFrame( int w, int h, int zoom, unsigned char* buf ) 302void ZCameraIO::captureFrame( int w, int h, int zoom, unsigned char* buf )
306{ 303{
307 //FIXME: this is too slow 304 //FIXME: this is too slow
308 int pw = _width; 305 int pw = _width;
309 int ph = _height; 306 int ph = _height;
310 if ( _rot ) 307 setCaptureFrame( w, h, zoom*256, _rot );
311 setCaptureFrame( h, w, zoom*256, true );
312 else
313 setCaptureFrame( w, h, zoom*256, false );
314
315 snapshot( buf ); 308 snapshot( buf );
316 setCaptureFrame( pw, ph, _zoom, _rot ); 309 setCaptureFrame( pw, ph, _zoom, _rot );
317} 310}
318 311