1 files changed, 2270 insertions, 0 deletions

diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
new file mode 100644
index 0000000..4223d93
--- a/dev/null
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -0,0 +1,2270 @@
+/****************************************************************************
+ // qtrec.cpp
+ Created: Thu Jan 17 11:19:58 2002
+ copyright 2002 by L.J. Potter <ljp@llornkcor.com>
+****************************************************************************/
+
+#define DEV_VERSION
+
+#include "pixmaps.h"
+#include "qtrec.h"
+#include "helpwindow.h"
+#include "device.h"
+#include "wavFile.h"
+
+#include <pthread.h>
+
+extern "C" {
+#include "adpcm.h"
+}
+
+#include <sys/soundcard.h>
+
+// #if defined (QTOPIA_INTERNAL_FSLP)
+// #include <qpe/lnkproperties.h>
+// #endif
+
+#include <qpe/applnk.h>
+#include <qpe/config.h>
+#include <qpe/ir.h>
+#include <qpe/qcopenvelope_qws.h>
+#include <qpe/qpeapplication.h>
+#include <qpe/resource.h>
+#include <qpe/storage.h>
+
+#include <qlineedit.h>
+#include <qbuttongroup.h>
+#include <qcheckbox.h>
+#include <qcombobox.h>
+#include <qcursor.h>
+//#include <qdatetime.h>
+#include <qdir.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qgroupbox.h>
+#include <qiconview.h>
+#include <qimage.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qlineedit.h>
+#include <qlistview.h>
+#include <qmessagebox.h>
+#include <qpixmap.h>
+#include <qpopupmenu.h>
+#include <qpushbutton.h>
+#include <qregexp.h>
+#include <qslider.h>
+#include <qtabwidget.h>
+#include <qtimer.h>
+#include <qvariant.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <math.h>
+#include <mntent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/soundcard.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/vfs.h>
+#include <unistd.h>
+#include<sys/wait.h>
+#include <sys/signal.h>
+
+//#define ZAURUS 0
+struct adpcm_state encoder_state;
+struct adpcm_state decoder_state;
+
+long findPeak(long input );
+//char deviceRates[];
+
+typedef struct {
+   int sampleRate;
+   /*      int fragSize; */
+   /*      int blockSize; */
+   int resolution; //bitrate
+   int channels; //number of channels
+   int fd; //file descriptor
+   int sd; //sound device descriptor
+   int numberSamples; //total number of samples
+   int SecondsToRecord; // number of seconds that should be recorded
+   float numberOfRecordedSeconds; //total number of samples recorded
+   int samplesToRecord; //number of samples to be recorded
+   int inVol; //input volume
+   int outVol; //output volume
+   int format; //wavfile format PCM.. ADPCM
+   const  char *fileName; //name of fiel to be played/recorded
+} fileParameters;
+
+fileParameters filePara;
+
+bool monitoring, recording;
+bool stopped;
+QLabel *timeLabel;
+QSlider *timeSlider;
+int sd;
+
+#if defined(QT_QWS_EBX)
+#define DSPSTROUT "/dev/dsp"
+#define DSPSTRIN "/dev/dsp1"
+#define DSPSTRMIXEROUT "/dev/mixer"
+#define DSPSTRMIXERIN "/dev/mixer1"
+#else
+#define DSPSTROUT "/dev/dsp"
+#define DSPSTRIN "/dev/dsp"
+#define DSPSTRMIXERIN "/dev/mixer"
+#define DSPSTRMIXEROUT "/dev/mixer"
+#endif
+
+// threaded recording
+void quickRec() {
+//void QtRec::quickRec() {
+
+   qDebug("%d",
+          filePara.numberSamples/filePara.sampleRate * filePara.channels);
+   qDebug("samples %d, rate %d, channels %d",
+          filePara.numberSamples, filePara.sampleRate, filePara.channels);
+
+   int total = 0;  // Total number of bytes read in so far.
+   int bytesWritten, number;
+
+   count_info info;
+
+   bytesWritten=0;
+   number=0;
+   QString num, timeString;
+   int level=0;
+   int threshold=0;
+   //     if(limit != 0)
+   //        t->start( ( limit +.3) , true);
+
+   recording = true;
+   //rate=filePara.sampleRate;
+   int bits = filePara.resolution;
+   qDebug("bits %d", bits);
+//   if( filePara.format==WAVE_FORMAT_DVI_ADPCM)
+//   else
+   audio_buf_info inInfo;
+   ioctl( filePara.fd, SNDCTL_DSP_GETISPACE, &inInfo);
+   qDebug("ispace is frags %d, total %d", inInfo.fragments, inInfo.fragstotal);
+
+   if( filePara.resolution == 16 ) { //AFMT_S16_LE)
+      qDebug("AFMT_S16_LE size %d", filePara.SecondsToRecord);
+      qDebug("samples to record %d", filePara.samplesToRecord);
+      qDebug("%d", filePara.sd);
+      level=7;
+      threshold=0;
+      timeString.sprintf("%.2f",  filePara.numberOfRecordedSeconds);
+      timeLabel->setText( timeString+ " seconds");
+
+      if( filePara.format==WAVE_FORMAT_DVI_ADPCM) {
+         qDebug("start recording WAVE_FORMAT_DVI_ADPCM");
+         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_DVI_ADPCM  >>>>>>>>>>>>>>>>>>>>>>
+         char abuf[BUFSIZE/2];
+         short sbuf[BUFSIZE];
+         short sbuf2[BUFSIZE];
+         memset( abuf,0,BUFSIZE/2);
+         memset( sbuf,0,BUFSIZE);
+         memset( sbuf2,0,BUFSIZE);
+
+         for(;;) {
+            if (stopped) {
+               qDebug("quickRec:: stopped");
+               break;  // stop if playing was set to false
+//                    return;
+            }
+
+            number=::read( filePara.sd, sbuf, BUFSIZE);
+
+            if(number <= 0) {
+               perror("recording error ");
+               qDebug( "%s %d", filePara.fileName, number);
+               //          errorStop();
+               recording=stopped=false;
+//                     QMessageBox::message("Note",
+//                                          "Error recording to file\n%s",
+//                                          filePara.fileName);
+               return;
+            }
+            //if(stereo == 2) {
+//        adpcm_coder( sbuf2, abuf, number/2, &encoder_state);
+            adpcm_coder( sbuf, abuf, number/2, &encoder_state);
+
+            bytesWritten = ::write( filePara.fd , abuf, number/4);
+
+            long peak;
+            for (int i = 0; i < number; i++)
+            { //since Z is mono do normally
+               peak = findPeak((long)sbuf[i]);
+               printf("peak %ld\r",peak);
+               fflush(stdout);
+            }
+            
+
+            //------------->>>> out to file
+            //           if(filePara.channels==1)
+            //               total += bytesWritten/2; //mono
+            //           else
+            total += bytesWritten;
+            filePara.numberSamples = total;
+//               if( total >= filePara.samplesToRecord)
+//                   timeSlider->setValue(0);
+//               else if( filePara.SecondsToRecord !=0)
+            timeSlider->setValue( total);
+
+            filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate * (float)2;
+
+//                 printf("Writing number %d, bytes %d,total %d, sample rate %d, secs %.2f \n",
+//                        number,
+//                        bytesWritten ,
+//                        total,
+//                        filePara.sampleRate,
+//                        filePara.numberOfRecordedSeconds);
+//                 fflush(stdout);
+            ioctl( filePara.sd, SNDCTL_DSP_GETIPTR, &info);
+//            qDebug("%d, %d", info.bytes, (info.bytes / filePara.sampleRate) / 2);
+
+            timeString.sprintf("%.2f", filePara.numberOfRecordedSeconds);
+            timeLabel->setText( timeString + " seconds");
+
+            qApp->processEvents();
+            if( total >= filePara.samplesToRecord)
+               break;
+         }
+      } else {
+         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
+         qDebug("start recording WAVE_FORMAT_PCM");
+         short inbuffer[BUFSIZE], outbuffer[BUFSIZE];
+         memset( inbuffer,0,BUFSIZE);
+         memset( outbuffer,0,BUFSIZE);
+         for(;;) {
+            if (stopped) {
+               qDebug("quickRec:: stopped");
+               break;  // stop if playing was set to false
+               return;
+            }
+
+            number=::read( filePara.sd, inbuffer, BUFSIZE);
+
+            if(number <= 0) {
+               perror("recording error ");
+               qDebug( filePara.fileName);
+               recording=stopped=false;
+               //          errorStop();
+//                    QMessageBox::message("Note","error recording to file\n%s",filePara.fileName);
+               return;// false;
+            }
+/*                for (int i=0;i< number;i++) { //2*i is left channel
+
+outbuffer[i]=inbuffer[i]>>1; // no clippy, please
+}*/
+            bytesWritten = ::write( filePara.fd , inbuffer, number);
+//------------->>>> out to file
+            if(bytesWritten < 0) {
+               //            errorStop();
+               perror("File writing error ");
+               return;// false;
+            }
+
+            //          if(filePara.channels==1)
+            //              total += bytesWritten/2; //mono
+            //          else
+            total += bytesWritten;
+            long peak;
+            for (int i = 0; i < number; i++)
+            { //since Z is mono do normally
+               peak = findPeak((long)inbuffer[i]);
+               printf("peak %ld\r",peak);
+               fflush(stdout);
+            }
+            
+
+            filePara.numberSamples = total;
+            if(filePara.SecondsToRecord !=0)
+               timeSlider->setValue( total);
+//         printf("Writing number %d, bytes %d,total %d\r",number,  bytesWritten , total);
+//         fflush(stdout);
+
+            ioctl( filePara.sd, SNDCTL_DSP_GETIPTR, &info);
+//            qDebug("%d, %d", info.bytes, ( info.bytes / filePara.sampleRate) / 2);
+                
+            filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2;
+
+            timeString.sprintf("%.2f", filePara.numberOfRecordedSeconds);
+            timeLabel->setText( timeString + " seconds");
+
+            qApp->processEvents();
+            if( total >= filePara.samplesToRecord)
+               break;
+         }
+      } //end main loop
+
+   } else { // <<<<<<<<<<<<<<<<<<<<<<<   format = AFMT_U8;
+      unsigned char unsigned_inbuffer[BUFSIZE], unsigned_outbuffer[BUFSIZE];
+      memset( unsigned_inbuffer, 0, BUFSIZE);
+      memset( unsigned_outbuffer, 0, BUFSIZE);
+
+      for(;;) {
+         if (stopped) {
+            qDebug("quickRec:: stopped");
+            break;  // stop if playing was set to false
+         }
+         number=::read( filePara.sd, unsigned_inbuffer, BUFSIZE);
+//-------------<<<< in from device
+//  val = (data ^ 0x80) << 8;
+
+//unsigned_outbuffer = (unsigned_inbuffer ^ 0x80) << 8;
+
+//       if(number <= 0) {
+//         perror("recording error ");
+//         qDebug(filePara.fileName);
+//         //        errorStop();
+//         QMessageBox::message("Note","error recording");
+//         return;// false;
+//       }
+//          for (int i=0;i< number;i++) { //2*i is left channel
+//              unsigned_outbuffer[i]=unsigned_inbuffer[i]>>1; // no clippy, please
+//          }
+
+         bytesWritten = ::write( filePara.fd , unsigned_inbuffer, number);
+
+//------------->>>> out to file
+         if(bytesWritten < 0) {
+            recording=stopped=false;
+            //          errorStop();
+            QMessageBox::message("Note","There was a problem\nwriting to the file");
+            perror("File writing error ");
+            return;// false;
+         }
+         total += bytesWritten;
+         filePara.numberSamples = total;
+         //             printf("\nWriting number %d, bytes %d,total %d \r",number,  bytesWritten , total);
+         //             fflush(stdout);
+         if(filePara.SecondsToRecord !=0)
+            timeSlider->setValue( total);
+
+         filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate;
+
+         timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
+         timeLabel->setText( timeString + " seconds");
+
+         qApp->processEvents();
+         if( total >= filePara.samplesToRecord)
+            break;
+      } //end main loop
+   }
+//       qDebug("Final %d, %d", filePara.samplesToRecord , filePara.numberOfRecordedSeconds);
+} /// END quickRec()
+
+// threaded play
+void playIt() {
+
+}
+
+
+
+/////////////////<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>
+/////////////////<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>
+
+QtRec::QtRec( QWidget* parent,  const char* name, WFlags fl )
+   : QWidget( parent, name, fl ) {
+   //    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << true;  // mute device
+   //  autoMute=TRUE;
+//     QPEApplication::grabKeyboard();
+
+//    signal(SIGPIPE, SIG_IGN);
+
+   if ( !name )
+      setName( "QpeRec" );
+   init();
+   initConfig();
+   initConnections();
+   renameBox = 0;
+
+// open sound device to get volumes
+   soundDevice = new Device( this, DSPSTROUT, DSPSTRMIXEROUT, false);
+
+//     soundDevice->setDeviceFormat(AFMT_S16_LE);
+//     soundDevice->setDeviceChannels(1);
+//     soundDevice->setDeviceRate( 22050);
+
+   getInVol();
+   getOutVol();
+
+   soundDevice->closeDevice(  true);
+   soundDevice->sd=-1;
+   soundDevice=0;
+   wavFile=0;
+
+   if(soundDevice) delete soundDevice;
+
+   initIconView();
+
+   if(autoMute)
+      doMute(true);
+   ListView1->setFocus();
+   playing=false;
+}
+
+QtRec::~QtRec() {
+
+}
+
+void QtRec::cleanUp() {
+
+   if(!stopped) {
+      stopped=true;
+      endRecording();
+   }
+
+   ListView1->clear();
+
+   if(autoMute)
+      doMute(false);
+
+   if(wavFile) delete wavFile;
+// if(soundDevice) delete soundDevice;
+
+//     QPEApplication::grabKeyboard();
+//     QPEApplication::ungrabKeyboard();
+}
+
+void QtRec::init() {
+
+   needsStereoOut=false;
+   QPixmap image3( ( const char** ) image3_data );
+   QPixmap image4( ( const char** ) image4_data );
+   QPixmap image6( ( const char** ) image6_data );
+
+   stopped=true;
+   setCaption( tr( "QpeRecord " ) + QString::number(VERSION) );
+   QGridLayout *layout = new QGridLayout( this );
+   layout->setSpacing( 2);
+   layout->setMargin( 2);
+
+   TabWidget = new QTabWidget( this, "TabWidget" );
+   layout->addMultiCellWidget(TabWidget, 0, 7, 0, 7);
+   //    TabWidget->setTabShape(QTabWidget::Triangular);
+
+   ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
+   tab = new QWidget( TabWidget, "tab" );
+
+   QGridLayout *layout1 = new QGridLayout( tab);
+   layout1->setSpacing( 2);
+   layout1->setMargin( 2);
+
+   timeSlider = new QSlider( 0,100,10,0, QSlider::Horizontal, tab, (const char *) "timeSlider" );
+   //    timeSlider->setFixedWidth(150);
+   layout1->addMultiCellWidget( timeSlider, 1, 1, 0, 3);
+//    timeSlider->setTickmarks(QSlider::Above);
+
+   timeLabel = new QLabel( tab, "TimeLabel" );
+   layout1->addMultiCellWidget( timeLabel, 0, 0, 0, 3);
+
+   playLabel2 = new QLabel(tab, "PlayLabel2" );
+   playLabel2->setText("Play");
+   playLabel2->setFixedHeight(18);
+   layout1->addMultiCellWidget( playLabel2, 0, 0, 4, 4);
+
+   Stop_PushButton = new QPushButton(  tab, "Stop_PushButton" );
+   layout1->addMultiCellWidget( Stop_PushButton, 1, 1, 4, 4);
+   Stop_PushButton->setFixedSize(22,22);
+   Stop_PushButton->setPixmap( image4 );
+
+   toBeginningButton = new QPushButton(  tab, "Beginning_PushButton" );
+   layout1->addMultiCellWidget(toBeginningButton, 1, 1, 5, 5);
+   toBeginningButton->setFixedSize(22,22);
+   toBeginningButton->setPixmap( Resource::loadPixmap("fastback") );
+
+   toEndButton = new QPushButton(  tab, "End_PushButton" );
+   layout1->addMultiCellWidget( toEndButton, 1, 1, 6, 6);
+   toEndButton->setFixedSize(22,22);
+   toEndButton->setPixmap(  Resource::loadPixmap( "fastforward" )  );
+
+   QLabel *recLabel2;
+   recLabel2 = new QLabel( tab, "recLabel2" );
+   recLabel2->setText("Rec");
+   recLabel2->setFixedHeight(18);
+   layout1->addMultiCellWidget( recLabel2, 0, 0, 7, 7);
+
+   Rec_PushButton = new QPushButton( tab, "Rec_PushButton" );
+   layout1->addMultiCellWidget(  Rec_PushButton, 1, 1, 7, 7);
+   Rec_PushButton->setFixedSize(22,22);
+   Rec_PushButton->setPixmap( image6 );
+
+   t = new QTimer( this );
+   connect( t, SIGNAL( timeout() ), SLOT( timerBreak() ) );
+
+   rewindTimer = new QTimer( this );
+   connect( rewindTimer, SIGNAL( timeout() ), SLOT( rewindTimerTimeout() ) );
+
+   forwardTimer = new QTimer( this );
+   connect( forwardTimer, SIGNAL( timeout() ), SLOT( forwardTimerTimeout() ) );
+
+   deleteSoundButton  = new QPushButton( tab, "deleteSoundButton" );
+   layout1->addMultiCellWidget( deleteSoundButton, 1, 1, 8, 8);
+   deleteSoundButton->setText( tr( "Delete" ) );
+
+   ListView1 = new QListView( tab, "IconView1" );
+   layout1->addMultiCellWidget( ListView1, 2, 2, 0, 8);
+
+   ListView1->addColumn( tr( "Name" ) );
+   ListView1->setColumnWidth(0,140);
+   ListView1->setSorting( 1, false);
+   ListView1->addColumn( tr( "Time" ) ); //in seconds
+   ListView1->setColumnWidth(1,50);
+   ListView1->addColumn( "Location");
+   ListView1->setColumnWidth(2,50);
+   ListView1->addColumn( "Date");
+   ListView1->setColumnWidth(3,63);
+
+   ListView1->setColumnWidthMode(0,QListView::Manual);
+   ListView1->setColumnAlignment(1,QListView::AlignCenter);
+   ListView1->setColumnAlignment(2,QListView::AlignRight);
+   ListView1->setColumnAlignment(3,QListView::AlignLeft);
+   ListView1->setAllColumnsShowFocus( true );
+   QPEApplication::setStylusOperation( ListView1->viewport(),QPEApplication::RightOnHold);
+
+   TabWidget->insertTab( tab, tr( "Files" ) );
+
+   ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
+   tab_3 = new QWidget( TabWidget, "tab_3" );
+   ////////////////////////////////////
+
+   Layout19 = new QHBoxLayout( tab_3);
+   Layout19->setSpacing( 2 );
+   Layout19->setMargin( 0 );
+
+   Layout18 = new QVBoxLayout(this);
+   Layout18->setSpacing( 2 );
+   Layout18->setMargin( 0 );
+
+   Layout17 = new QHBoxLayout(this);
+   Layout17->setSpacing( 2 );
+   Layout17->setMargin( 0 );
+
+   sampleGroup = new QGroupBox( tab_3, "samplegroup" );
+   sampleGroup->setTitle( tr( "Sample Rate" ) );
+   sampleGroup->setFixedSize( 95,50);
+
+   sampleRateComboBox = new QComboBox( false, sampleGroup, "SampleRateComboBox" );
+   sampleRateComboBox->setGeometry( QRect( 10, 20, 80, 25 ) );
+//#ifndef QT_QWS_EBX
+   sampleRateComboBox->insertItem( tr( "44100"));
+   sampleRateComboBox->insertItem( tr( "32000"));
+//#endif
+   sampleRateComboBox->insertItem( tr( "22050"));
+   //#ifndef QT_QWS_VERCEL_IDR
+   sampleRateComboBox->insertItem( tr( "16000"));    
+   sampleRateComboBox->insertItem( tr( "11025"));
+   sampleRateComboBox->insertItem( tr( "8000"));
+   //#endif
+
+   Layout17->addWidget( sampleGroup );
+
+   sizeGroup= new QGroupBox( tab_3, "sizeGroup" );
+   sizeGroup->setTitle( tr( "Limit Size" ) );
+   sizeGroup->setFixedSize(80,50);
+
+   sizeLimitCombo = new QComboBox( false, sizeGroup, "sizeLimitCombo" );
+   sizeLimitCombo ->setGeometry( QRect( 5, 20, 70, 25 ) );
+   sizeLimitCombo->insertItem(tr("Unlimited"));
+   for(int i=1;i<13; i++) {
+      sizeLimitCombo->insertItem( QString::number(i*5));
+   }
+
+//   sizeLimitCombo->insertItem(tr("5 secs"));
+//   sizeLimitCombo->insertItem(tr("10 secs"));
+//   sizeLimitCombo->insertItem(tr("15 secs"));
+//   sizeLimitCombo->insertItem(tr("20 secs"));
+
+   //  Layout18->addWidget( sizeGroup );
+   Layout17->addWidget( sizeGroup );
+
+   Layout18->addLayout( Layout17 );
+
+   Layout16 = new QHBoxLayout(this);
+   Layout16->setSpacing( 2 );
+   Layout16->setMargin( 0 );
+
+   dirGroup = new QGroupBox( tab_3, "dirGroup" );
+   dirGroup->setTitle( tr( "File Directory" ) );
+   dirGroup->setFixedSize(130,50);
+
+   directoryComboBox = new QComboBox( false, dirGroup, "dirGroup" );
+   directoryComboBox->setGeometry( QRect( 10, 15, 115, 25 ) );
+
+   Layout18->addWidget( dirGroup );
+
+   bitGroup = new QGroupBox( tab_3, "bitGroup" );
+   bitGroup->setTitle( tr( "Bit Depth" ) );
+   bitGroup->setFixedSize(65,50);
+
+   bitRateComboBox = new QComboBox( false, bitGroup, "BitRateComboBox" );
+   bitRateComboBox->insertItem( tr( "16" ) );
+   bitRateComboBox->insertItem( tr( "8" ) );
+   bitRateComboBox->setGeometry( QRect( 5, 20, 50, 25 ) );
+
+   Layout18->addWidget( bitGroup );
+
+   compressionCheckBox = new QCheckBox ( "Wave Compression (smaller files)", tab_3 );
+   Layout18->addWidget( compressionCheckBox );
+
+   autoMuteCheckBox= new QCheckBox ( "auto Mute", tab_3 );
+   Layout18->addWidget( autoMuteCheckBox );
+
+   Layout19->addLayout( Layout18 );
+
+   QWidget *d = QApplication::desktop();
+   int width=d->width();
+   int height=d->height();
+
+
+
+   if( width < height) {
+
+      tab_5 = new QWidget( TabWidget, "tab_5" );
+
+      QHBoxLayout *Layout19a;
+      Layout19a = new QHBoxLayout( tab_5);
+      Layout19a->setSpacing( 2 );
+      Layout19a->setMargin( 0 );
+
+
+      Layout15 = new QVBoxLayout(this);
+      Layout15->setSpacing( 2 );
+      Layout15->setMargin( 0 );
+
+      Layout15b = new QVBoxLayout(this);
+      Layout15b->setSpacing( 2 );
+      Layout15b->setMargin( 0 );
+
+      TextLabel2 = new QLabel( tab_5, "InputLabel" );
+      TextLabel2->setText( tr( "In"));
+      TextLabel2->setFixedWidth(35);
+      Layout15->addWidget( TextLabel2 );
+
+      TextLabel3 = new QLabel( tab_5, "OutputLabel" );
+      TextLabel3->setText( tr( "Out" ) );
+      Layout15b->addWidget( TextLabel3 );
+
+      InputSlider = new QSlider( -100, 0, 10, 0, QSlider::Vertical, tab_5, (const char *) "InputSlider" );
+      InputSlider->setTickmarks(QSlider::Both);
+      Layout15->addWidget( InputSlider);
+
+      OutputSlider = new QSlider( -100,0,10,0, QSlider::Vertical,tab_5,(const char *) "OutputSlider" );
+      OutputSlider->setTickmarks(QSlider::Both);
+
+      Layout15b->addWidget( OutputSlider );
+
+      outMuteCheckBox = new QCheckBox ( "mute", tab_5 );
+      Layout15->addWidget( outMuteCheckBox );
+
+      inMuteCheckBox = new QCheckBox ( "mute", tab_5 );
+      inMuteCheckBox-> setFocusPolicy ( QWidget::NoFocus );
+      Layout15b->addWidget( inMuteCheckBox );
+
+
+      Layout19a->addLayout( Layout15 );
+      Layout19a->addLayout( Layout15b );
+
+      fillDirectoryCombo();
+
+      TabWidget->insertTab( tab_3, tr( "Options" ) );
+
+      TabWidget->insertTab( tab_5, tr( "Volume" ) );
+
+   } else {// landscape
+
+      //  Layout16->addWidget( dirGroup );
+      //  Layout18->addLayout( Layout16 );
+      Layout15 = new QVBoxLayout(this);
+      Layout15->setSpacing( 2 );
+      Layout15->setMargin( 0 );
+
+      Layout15b = new QVBoxLayout(this);
+      Layout15b->setSpacing( 2 );
+      Layout15b->setMargin( 0 );
+
+      TextLabel2 = new QLabel( tab_3, "InputLabel" );
+      TextLabel2->setText( tr( "In"));
+      TextLabel2->setFixedWidth(35);
+      Layout15->addWidget( TextLabel2 );
+
+      TextLabel3 = new QLabel( tab_3, "OutputLabel" );
+      TextLabel3->setText( tr( "Out" ) );
+      Layout15b->addWidget( TextLabel3 );
+
+      InputSlider = new QSlider( -100, 0, 10, 0, QSlider::Vertical, tab_3, (const char *) "InputSlider" );
+      //   InputSlider->setTickmarks(QSlider::Both);
+      Layout15->addWidget( InputSlider);
+
+      OutputSlider = new QSlider( -100,0,10,0, QSlider::Vertical,tab_3,(const char *) "OutputSlider" );
+      //   OutputSlider->setTickmarks(QSlider::Both);
+
+      Layout15b->addWidget( OutputSlider );
+
+      outMuteCheckBox = new QCheckBox ( "mute", tab_3 );
+      Layout15->addWidget( outMuteCheckBox );
+
+      inMuteCheckBox = new QCheckBox ( "mute", tab_3 );
+      inMuteCheckBox-> setFocusPolicy ( QWidget::NoFocus );
+      Layout15b->addWidget( inMuteCheckBox );
+
+
+      Layout19->addLayout( Layout15 );
+      Layout19->addLayout( Layout15b );
+
+      fillDirectoryCombo();
+
+      TabWidget->insertTab( tab_3, tr( "Options" ) );
+
+   }
+
+
+   ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
+
+   tab_4 = new QWidget( TabWidget, "tab_4" );
+   QGridLayout *layout4 = new QGridLayout( tab_4);
+   layout4->setSpacing( 2);
+   layout4->setMargin( 2);
+   TabWidget->insertTab( tab_4, tr( "Help"));
+
+   ///////////////////////////////////////////// FIXME change to a real helpfile path
+   QString url="/index.html";
+   HelpWindow *help = new HelpWindow( url, ".", tab_4, "qperec_help");
+   layout4->addMultiCellWidget( help, 0, 1, 0, 1);
+   if( !QFile(url).exists()) {
+      help->hide();
+      //help->showMaximized();
+      QLabel *helpLabel;
+      helpLabel = new QLabel( tab_4, "TimeLabel" );
+      layout4->addMultiCellWidget( helpLabel, 0, 3, 0, 4 );
+      helpLabel->setText( "<B>QpeRec</B><br>"
+                          "Records files in standard wav format<br>"
+                          "or a compressed version<br>"
+                          "For help, please email the author<br>"
+                          "<B>QpeRec</B> is copyright&copy; 2002 by"
+                          " L.J. Potter<br>llornkcor@handhelds.org<BR>"
+                          "and is licensed under the <B>QPL</B>");
+   }
+   ///**********<<<<<<<<<<<<>>>>>>>>>>>>***************
+
+}
+
+void QtRec::initIconView() {
+
+   ListView1->clear();
+   Config cfg("QpeRec");
+   cfg.setGroup("Sounds");
+   QString temp;
+   QPixmap image0( ( const char** ) image0_data );
+
+
+   int nFiles = cfg.readNumEntry("NumberofFiles",0);
+   for(int i=1;i<= nFiles;i++) {
+
+      QListViewItem * item;
+      QString fileS, mediaLocation, fileDate,  filePath;
+
+//      temp.sprintf("%d",i);
+      temp=cfg.readEntry(temp,""); //reads currentFile
+      filePath = cfg.readEntry(temp,""); //currentFileName
+
+      QFileInfo info(filePath);
+      fileDate = info.lastModified().toString();
+
+      fileS = cfg.readEntry( filePath, "0" );// file length in seconds
+      mediaLocation=getStorage( filePath);
+      if(info.exists()) {
+         item = new QListViewItem( ListView1, temp,  fileS,  mediaLocation, fileDate);
+         item->setPixmap( 0, image0);
+         if(currentFileName == filePath)
+            ListView1->setSelected( item, true);
+      }
+   }
+}
+
+void QtRec::initConnections() {
+   connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
+
+   connect( toBeginningButton, SIGNAL( pressed()), this, SLOT( rewindPressed() ));
+   connect( toBeginningButton, SIGNAL( released()), this, SLOT( rewindReleased() ));
+   connect( toEndButton, SIGNAL( pressed()), this, SLOT( FastforwardPressed() ));
+   connect( toEndButton, SIGNAL( released()), this, SLOT( FastforwardReleased() ));
+   connect( deleteSoundButton, SIGNAL(released()), this, SLOT( deleteSound() ));
+   connect( Stop_PushButton, SIGNAL(released()), this, SLOT( doPlayBtn() ));
+   connect( Rec_PushButton, SIGNAL(released()), this, SLOT( newSound() ) );
+   connect( TabWidget, SIGNAL( currentChanged( QWidget*)),this, SLOT(thisTab(QWidget*) ));
+   connect( OutputSlider, SIGNAL(sliderReleased()), this, SLOT( changedOutVolume()) );
+   connect( InputSlider, SIGNAL(sliderReleased()), this, SLOT( changedInVolume()) );
+
+   //   connect( OutputSlider, SIGNAL(valueChanged( int)), this, SLOT(changedOutVolume(int)) );
+   //   connect( InputSlider, SIGNAL(valueChanged( int)), this, SLOT(changedInVolume(int)) );
+
+   connect( sampleRateComboBox, SIGNAL(activated( int)), this, SLOT( changesamplerateCombo(int)) );
+   connect( bitRateComboBox, SIGNAL(activated( int)), this, SLOT( changebitrateCombo(int)) );
+   connect( directoryComboBox, SIGNAL(activated( int)), this, SLOT( changeDirCombo(int)) );
+   connect( sizeLimitCombo, SIGNAL(activated( int)), this, SLOT( changeSizeLimitCombo(int)) );
+   connect( outMuteCheckBox, SIGNAL(toggled( bool)), this, SLOT( doVolMuting(bool)) );
+   connect( inMuteCheckBox , SIGNAL(toggled( bool)), this, SLOT( doMicMuting(bool)) );
+   connect( ListView1,SIGNAL(doubleClicked( QListViewItem*)),this,SLOT( itClick(QListViewItem*)));
+   connect( ListView1, SIGNAL( mouseButtonPressed( int, QListViewItem *, const QPoint&, int)),
+            this,SLOT( listPressed(int, QListViewItem *, const QPoint&, int)) );
+   connect( timeSlider, SIGNAL( sliderMoved( int)), this, SLOT( changeTimeSlider(int) ));
+   connect( timeSlider, SIGNAL( sliderPressed( )), this, SLOT( timeSliderPressed() ));
+   connect( timeSlider, SIGNAL( sliderReleased( )), this, SLOT( timeSliderReleased() ));
+   connect( compressionCheckBox, SIGNAL( toggled(bool)),this, SLOT( compressionSelected(bool)));
+   connect( autoMuteCheckBox, SIGNAL( toggled(bool)),this, SLOT( slotAutoMute(bool)));
+}
+
+void QtRec::initConfig() {
+   int index, fred, i;
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+
+   index = cfg.readNumEntry("samplerate",22050);
+   bool ok;
+
+   for(int ws=0;ws<sampleRateComboBox->count();ws++) {
+      fred = sampleRateComboBox->text(ws).toInt(&ok, 10);
+      if(index == fred) {
+         filePara.sampleRate  = fred;
+         sampleRateComboBox->setCurrentItem(ws);
+      }
+   }
+
+   i=cfg.readNumEntry("bitrate",16);
+   if(i == 16)
+      bitRateComboBox->setCurrentItem( 0);
+   else
+      bitRateComboBox->setCurrentItem( 1);
+   filePara.resolution = i;
+
+   i=cfg.readNumEntry("sizeLimit", 5 );
+   QString temp;
+//     for(int i=1;i<13; i++) {
+//        temp = sizeLimitCombo->text(i);
+        
+//         sizeLimitCombo->insertItem( QString::number(i*5)+tr(" secs"));
+//     }
+   sizeLimitCombo->setCurrentItem((i/5));
+
+   compressionCheckBox->setChecked( cfg.readBoolEntry("wavCompression",1));
+   if( compressionCheckBox->isChecked()) {
+      bitRateComboBox->setEnabled(false);
+      bitRateComboBox->setCurrentItem(0);
+      filePara.resolution=16;
+   }
+
+   autoMuteCheckBox->setChecked( cfg.readBoolEntry("useAutoMute",0));
+   if( autoMuteCheckBox->isChecked())
+      slotAutoMute(true);
+   else
+      slotAutoMute(false);
+
+   Config cofg( "qpe");
+   cofg.setGroup( "Volume");
+   outMuteCheckBox->setChecked( cofg.readBoolEntry( "Mute",0));
+   inMuteCheckBox->setChecked( cofg.readBoolEntry( "MicMute",0));
+}
+
+//================
+
+void QtRec::stop() {
+   qDebug("<<<<<<<<<stop()");
+   setRecordButton(false);
+   monitoring=false;
+   stopped=true;
+
+   if( !recording)
+      endPlaying();
+   else
+      endRecording();
+   timeSlider->setValue(0);
+   //    QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << true;  // mute device
+}
+
+void QtRec::doPlayBtn() {
+
+   if(!stopped) {
+      playLabel2->setText("Play");
+      stop();
+   } else {
+      if(ListView1->currentItem() == 0) return;
+      playLabel2->setText("Stop");
+      currentFile = ListView1->currentItem()->text(0);
+      start();
+   }
+}
+
+void QtRec::start() { //play
+   if(stopped) {
+      qDebug("start::");
+      QPixmap image3( ( const char** ) image3_data );
+      Stop_PushButton->setPixmap( image3 );
+      Stop_PushButton->setDown(true);
+      stopped=false;
+      paused=false;
+      secCount=1;
+
+      if( openPlayFile())
+         if( setupAudio( false))  //recording is false
+            doPlay();
+   }
+}
+
+bool QtRec::rec() { //record
+   qDebug("rec()");
+   if(!stopped) {
+      qDebug("rec:: !stopped");
+      monitoring=true;
+      return false;
+   } else {
+      qDebug("go ahead and record");
+      secCount=1;
+      playLabel2->setText("Stop");
+      monitoring=false;
+      setRecordButton(true);
+      stopped=false;
+  
+      if( setupAudio( true)) 
+         if(setUpFile())  {
+            qDebug("Ok to start recording");
+            int fileSize=0;
+            Config cfg("QpeRec");
+            cfg.setGroup("Settings");
+            qDebug( "<<<<<<<Device bits %d, device rate %d, device channels %d",
+                    soundDevice->getDeviceBits(),
+                    soundDevice->getDeviceRate(),
+                    soundDevice->getDeviceChannels());
+
+            //filePara.sampleRate = cfg.readNumEntry("samplerate", 22050);
+            qDebug("sample rate is %d", filePara.sampleRate);
+            filePara.SecondsToRecord = getCurrentSizeLimit();
+
+            qDebug("size limit %d sec", filePara.SecondsToRecord);
+            int diskSize = checkDiskSpace( (const QString &) wavFile->trackName());
+
+            if( filePara.SecondsToRecord == 0) {
+               fileSize = diskSize;
+            } else if( filePara.format==WAVE_FORMAT_PCM) {
+               qDebug("WAVE_FORMAT_PCM");
+               fileSize = (filePara.SecondsToRecord ) * filePara.channels
+                          * filePara.sampleRate *(filePara.resolution/8)+1000;
+            } else {
+               qDebug("WAVE_FORMAT_DVI_ADPCM");
+               fileSize = ((filePara.SecondsToRecord) * filePara.channels
+                           * filePara.sampleRate *(filePara.resolution/8) )/4+250;
+            }
+
+            filePara.samplesToRecord = fileSize;
+            qDebug("filesize should be %d, bits %d, rate %d",
+                   filePara.samplesToRecord, filePara.resolution, filePara.sampleRate);
+            if(paused) {
+               paused = false;
+            }
+            //                  else {
+            qDebug("Setting timeslider %d", filePara.samplesToRecord);
+            //           if(fileSize != 0)
+            timeSlider->setRange(0, filePara.samplesToRecord);
+            //                  }
+
+            if( diskSize < fileSize/1024) {
+               QMessageBox::warning(this,
+                                    tr("Low Disk Space"),
+                                    tr("You are running low of\nrecording space\n"
+                                       "or a card isn't being recognized"));
+               stopped = true; //we need to be stopped
+               stop();
+            } else {
+               QString msg;
+               msg.sprintf("%d, %d, %d", filePara.sampleRate, filePara.channels, filePara.resolution);
+#ifdef DEV_VERSION
+               setCaption( msg);
+#endif
+               filePara.fileName=currentFile.latin1();
+               qDebug("Start recording thread");
+
+               pthread_t thread1;
+               pthread_create( &thread1, NULL, (void * (*)(void *))quickRec, NULL/* &*/);
+//                            quickRec();
+               toBeginningButton->setEnabled(false);
+               toEndButton->setEnabled(false);
+
+               startTimer(1000);
+            }
+         } //end setUpFile
+   } //end setupAudio
+   //             _exit( 0);
+   
+   // ///*      default:
+//      //     /* pid greater than zero is parent getting the child's pid */
+// /*          printf("Child's pid is %d\n",pid);
+//             waitpid( pid, &status, 0);
+//            printf("Child[%d] exited with status %d\n", pid, status);*/
+   // while (wait(NULL) != pid)
+//               ;
+//           printf("child %ld terminated normally, return status is zero\n", (long) pid);
+   //   endRecording();
+/* else { //device was not opened
+   qDebug("Audio device open failed");
+   return false;
+   }
+   }*/
+// } //end fork
+// }
+// }
+   return true;
+}
+/*
+  This happens when a tab is selected*/
+void QtRec::thisTab(QWidget* widg) {
+   if(widg != NULL) {
+      int index=TabWidget->currentPageIndex();
+
+      if(index==0) { //file page
+      }
+
+      if(index ==1) { //control page
+         fillDirectoryCombo();
+//       soundDevice->getOutVol();
+//       soundDevice->getInVol();
+      }
+
+      if(index==2) { //help page
+      }
+      qApp->processEvents();
+      update();
+   }
+}
+
+void QtRec::getOutVol( ) {
+   filePara.outVol = soundDevice->getOutVolume();
+   qDebug("out vol %d", filePara.outVol);
+   OutputSlider->setValue( -filePara.outVol);
+}
+
+void QtRec::getInVol() {
+   filePara.inVol = soundDevice->getInVolume();
+   qDebug("in vol %d", filePara.inVol);
+   InputSlider->setValue( -filePara.inVol);
+}
+
+void QtRec::changedOutVolume() {
+   soundDevice->changedOutVolume(-OutputSlider->value());
+}
+
+void QtRec::changedInVolume( ) {
+   soundDevice->changedInVolume( -InputSlider->value());
+}
+
+
+bool QtRec::setupAudio( bool b) {
+   bool ok;
+   int  sampleformat, stereo, flags;
+   char * dspString, *mixerString;
+
+   filePara.resolution = bitRateComboBox->currentText().toInt( &ok,10);  //16
+
+   if( !b){ // we want to play
+      qDebug("setting up DSP for playing");
+      if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
+         sampleformat = AFMT_S16_LE;
+         filePara.resolution = 16;
+      } else {
+         sampleformat = AFMT_U8;
+         filePara.resolution=8;
+      }
+
+      stereo = filePara.channels = 1;
+      flags= O_WRONLY;
+      dspString = DSPSTROUT;
+      mixerString = DSPSTRMIXEROUT;
+   } else { // we want to record
+      qDebug("setting up DSP for recording");
+
+      if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
+         sampleformat = AFMT_S16_LE;
+      else
+         sampleformat = AFMT_U8;
+
+      if( !compressionCheckBox->isChecked()) {
+         filePara.format=WAVE_FORMAT_PCM;
+         qDebug("WAVE_FORMAT_PCM");
+      }  else {
+         filePara.format=WAVE_FORMAT_DVI_ADPCM;
+         sampleformat=AFMT_S16_LE;
+         qDebug("WAVE_FORMAT_DVI_ADPCM");
+      }
+
+      stereo = filePara.channels = 1;
+//        filePara.sampleRate = sampleRateComboBox->currentText().toInt( &ok,10);//44100;
+      flags= O_RDWR;
+//        flags= O_RDONLY;
+      dspString = DSPSTRIN;
+      mixerString = DSPSTRMIXEROUT;
+   }
+
+   // if(soundDevice) delete soundDevice;
+   qDebug("<<<<<<<<<<<<<<<<<<<open dsp %d %d %d", filePara.sampleRate, filePara.channels, sampleformat);
+   soundDevice = new Device( this, dspString, mixerString, b);
+//    soundDevice->openDsp();
+   soundDevice->reset();
+
+   qDebug("device has been made %d", soundDevice->sd);
+    
+   //////////////////         <<<<<<<<<<<<>>>>>>>>>>>>
+   soundDevice->setDeviceFormat( sampleformat);
+   soundDevice->setDeviceChannels( filePara.channels);
+   soundDevice->setDeviceRate( filePara.sampleRate);
+   soundDevice->getDeviceFragSize();
+#ifdef QT_QWS_EBX   
+   int frag = FRAGSIZE;
+   soundDevice->setFragSize( frag);
+   soundDevice->getDeviceFragSize();
+#endif    
+   /////////////////
+   filePara.sd = soundDevice->sd;
+
+   if ( filePara.sd == -1) {
+
+      monitoring=false;
+      stopped=true;
+      update();
+      setCaption( tr( "QpeRecord " ) + QString::number(VERSION) );
+      stopped=true;
+      return false;
+   }
+   if(autoMute)
+      doMute(false);
+
+   return true;
+}
+
+
+bool QtRec::setUpFile() { //setup file for recording
+   qDebug("Setting up wavfile");
+//  if(wavFile) delete wavFile;
+   wavFile = new WavFile( this, (const QString &)"",
+                          true,
+                          filePara.sampleRate,
+                          filePara.channels,
+                          filePara.resolution,
+                          filePara.format);
+
+   filePara.fd = wavFile->wavHandle();
+   if(filePara.fd == -1) {
+      return false;
+   } else {
+      filePara.channels=1;
+   }
+   return true;
+}
+
+/// <<<<<<<<<<<<<<<<  PLAY >>>>>>>>>>>>>>>>>>>
+bool QtRec::doPlay() {
+
+//    pthread_t thread2;
+//   pthread_create( &thread2, NULL, (void * (*)(void *))playIt, NULL/* &*/);
+
+   //  qDebug("doPlay file %d", filePara.fd);
+   int bytesWritten, number;
+   recording = false;
+//    int number=0;
+   if( !paused) {
+      qDebug("new");
+      total=0;
+      bytesWritten=0;
+      filePara.numberOfRecordedSeconds = 0;
+   } else {
+      paused = false;
+      secCount = (int)filePara.numberOfRecordedSeconds;
+   }
+   playing=true;
+   number=0;
+
+   QString num;
+//    block=BUFSIZE;
+   qDebug("Play number of samples %d", filePara.numberSamples);
+   timeSlider->setRange(0, filePara.numberSamples);
+   timeString.sprintf("%.2f",  filePara.numberOfRecordedSeconds);
+   timeLabel->setText( timeString+ tr(" seconds"));
+
+   if( filePara.format==WAVE_FORMAT_DVI_ADPCM) {
+      qDebug("WAVE_FORMAT_DVI_ADPCM");
+   } else {
+      qDebug("WAVE_FORMAT_PCM");
+   }
+   QString msg;
+   msg.sprintf("%d, %d, %d", filePara.sampleRate, filePara.channels, filePara.resolution);
+#ifdef DEV_VERSION
+   setCaption( msg);
+#endif
+   if( filePara.resolution == 16 ) { //AFMT_S16_LE) {
+      qDebug("16 bit");
+
+      startTimer(1000);
+
+      if( filePara.format==WAVE_FORMAT_DVI_ADPCM) {
+         char abuf[BUFSIZE/2];
+         short sbuf[BUFSIZE];
+         short sbuf2[BUFSIZE*2];
+         memset( abuf, 0, BUFSIZE / 2);
+         memset( sbuf, 0, BUFSIZE);
+         memset( sbuf2, 0, BUFSIZE * 2);
+// <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_DVI_ADPCM  >>>>>>>>>>>>>>>>>>>>>>
+         for(;;) {  // play loop
+            if (stopped)
+               break;  // stop if playing was set to false
+
+
+            number=::read( filePara.fd, abuf, BUFSIZE/2);
+            adpcm_decoder( abuf, sbuf, number*2, &decoder_state);
+
+//                 for (int i=0;i< number * 2; 2 * i++) { //2*i is left channel
+//                     sbuf2[i+1]=sbuf2[i]=sbuf[i];
+//                 }
+
+            bytesWritten = write ( filePara.sd, sbuf, number*4);
+            //          if(filePara.channels==1)
+            //              total += bytesWritten/2; //mono
+            //          else
+            total += bytesWritten;
+            timeSlider->setValue( total / 4);
+
+            filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / 2;
+
+            timeString.sprintf("%.2f", filePara.numberOfRecordedSeconds);
+//         if(filePara.numberOfRecordedSeconds>1)
+            timeLabel->setText( timeString+ tr(" seconds"));
+//         printf("playing number %d, bytes %d, total %d\n",number,  bytesWritten, total/4);
+//           printf("playing number %d, bytes %d, total %d totalsamples %d number recorded seconds %.2f\r",
+//    number,  bytesWritten, total/4, filePara.numberSamples, filePara.numberOfRecordedSeconds);
+//           fflush(stdout);
+
+            qApp->processEvents();
+
+            if( bytesWritten <= 0 ){//||  secCount > filePara.numberOfRecordedSeconds ) {
+               stopped = true;
+               endPlaying();
+            }
+         }
+      } else {
+         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
+         short inbuffer[BUFSIZE], outbuffer[BUFSIZE];
+         memset( inbuffer, 0, BUFSIZE);
+         memset( outbuffer, 0, BUFSIZE);
+
+         for(;;) {  // play loop
+            if (stopped)
+               break;  // stop if playing was set to false
+            number=::read( filePara.fd, inbuffer, BUFSIZE);
+//                 for (int i=0;i< number * 2; 2 * i++) { //2*i is left channel
+//                       //        for (int i=0;i< number ; i++) { //2*i is left channel
+//                     outbuffer[i+1]= outbuffer[i]=inbuffer[i];
+//                 }
+
+            bytesWritten = ::write( filePara.sd, inbuffer, number);
+            //-------------->>>> out to device
+            //        total+=bytesWritten;
+            //          if(filePara.channels==1)
+            //              total += bytesWritten/2; //mono
+            //          else
+            total += bytesWritten;
+
+            timeSlider->setValue( total);
+            filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2;
+
+            timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
+            timeLabel->setText( timeString + tr(" seconds"));
+
+            qApp->processEvents();
+
+            if( bytesWritten <= 0 &&  secCount > filePara.numberOfRecordedSeconds ) {
+               stopped = true;
+               endPlaying();
+            }
+         }
+//            printf("\nplaying number %d, bytes %d, total %d\r",number,  bytesWritten, total);
+//            fflush(stdout);
+      } //end loop
+   } else { /////////////////////////////// format = AFMT_U8;
+      unsigned char unsigned_inbuffer[BUFSIZE], unsigned_outbuffer[BUFSIZE];
+      memset( unsigned_inbuffer,0,BUFSIZE);
+      for(;;) {          // main loop
+         if (stopped)
+            break;  // stop if playing was set to false
+         number=::read( filePara.fd, unsigned_inbuffer, BUFSIZE);
+//data = (val >> 8) ^ 0x80;
+         //          unsigned_outbuffer = (unsigned_inbuffer >> 8) ^ 0x80;
+         bytesWritten = write ( filePara.sd, unsigned_inbuffer, number);
+         total+=bytesWritten;
+
+         timeSlider->setValue( total);
+
+         filePara.numberOfRecordedSeconds=(float)total/(float)filePara.sampleRate;
+         timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
+         timeLabel->setText( timeString + tr(" seconds"));
+         qApp->processEvents();
+
+         if( bytesWritten <= 0 &&  secCount > filePara.numberOfRecordedSeconds ) {
+            stopped = true;
+            endPlaying();
+         }
+         //             printf("Writing number %d, bytes %d, total %d, numberSamples %d\r",number,  bytesWritten , total, filePara.numberSamples);
+         //             fflush(stdout);
+      }
+   }
+
+//  qDebug("\nstopped or paused %d", total/4);
+   if(!paused && !stopped) {
+      stopped = true;
+//         endPlaying();
+      endPlaying();
+   }
+   return true;
+}
+
+
+void QtRec::changebitrateCombo(int i) {
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   int bits=0;
+   if(i==0) { bits=16; }
+   else { bits=8; }
+   cfg.writeEntry("bitrate", bits);
+   filePara.resolution=bits;
+   cfg.write();
+}
+
+void QtRec::changesamplerateCombo(int i) {
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   int rate=0;
+   bool ok;
+   rate = sampleRateComboBox->text(i).toInt(&ok, 10);
+   cfg.writeEntry("samplerate",rate);
+   filePara.sampleRate=rate;
+/*     soundDevice = new Device( this, DSPSTROUT, DSPSTRMIXER, false);
+       soundDevice->openDsp();*/
+// 
+//     soundDevice->setDeviceFormat(AFMT_S16_LE);
+//     soundDevice->setDeviceChannels(filePara.channels);
+//     soundDevice->setDeviceRate(filePara.sampleRate);
+// 
+//     soundDevice->closeDevice( true);
+//     soundDevice=0;
+//     delete soundDevice;
+   qDebug("Change sample rate %d", rate);
+   cfg.write();
+
+}
+
+
+void QtRec::changeDirCombo(int index) {
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   QString sName = directoryComboBox->text(index);
+
+   StorageInfo storageInfo;
+   const QList<FileSystem> &fs = storageInfo.fileSystems();
+   QListIterator<FileSystem> it ( fs );
+   QString storage;
+   for( ; it.current(); ++it ){
+      if( sName == (*it)->name()+" "+  (*it)->path() ||
+          (*it)->name() == sName ) {
+         const QString path = (*it)->path();
+         recDir =  path;
+         cfg.writeEntry("directory", recDir);
+         qDebug("new rec dir "+recDir);
+      }
+   }
+   cfg.write();
+}
+
+
+void QtRec::changeSizeLimitCombo(int) {
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   cfg.writeEntry("sizeLimit", getCurrentSizeLimit() );
+   cfg.write();
+}
+
+void QtRec::newSound() {
+   qDebug("<<<<<<<<<new sound");
+
+   if( !rec()) {
+      qDebug("rec() failed");
+      endRecording();
+      deleteSound();
+   }
+
+}
+
+void QtRec::itClick(QListViewItem *item) {
+   currentFile=item->text(0);
+   setCaption("QpeRecord  "+currentFile);
+}
+
+void QtRec::deleteSound() {
+   Config cfg("QpeRec");
+   cfg.setGroup("Sounds");
+   if(  ListView1->currentItem() == NULL)
+      return;
+#ifndef DEV_VERSION
+   switch ( QMessageBox::warning(this,tr("Delete"),
+                                 tr("Do you really want to <font size=+2><B>DELETE</B></font>\nthe selected file?"),
+                                 tr("Yes"),tr("No"),0,1,1) ) {
+   case 0:
+#endif
+   {
+      QString file = ListView1->currentItem()->text(0);
+      //    qDebug("Filename to find is "+file);
+      QString fileName;
+      fileName = cfg.readEntry( file, "");
+      QFile f(fileName);
+      //    qDebug("fileName is "+fileName);
+      if(f.exists())
+         if( !f.remove())
+            QMessageBox::message(tr("Error"),tr("Could not remove file."));
+
+      int nFiles = cfg.readNumEntry("NumberofFiles",0);
+      bool found=false;
+      for(int i=0;i<nFiles+1;i++) {
+         //        qDebug(cfg.readEntry(QString::number(i)));
+
+         if( cfg.readEntry( QString::number(i),"").find( file,0,true) != -1) {
+            found = true;
+//        qDebug( cfg.readEntry(QString::number(i))+"\n" +cfg.readEntry(QString::number(i+1)) );
+            cfg.writeEntry( QString::number(i), cfg.readEntry( QString::number(i+1),""));
+         }
+         if(found)
+            cfg.writeEntry( QString::number(i), cfg.readEntry( QString::number(i+1),""));
+      }
+
+      cfg.removeEntry(cfg.readEntry(file));
+      cfg.removeEntry( file);
+      //    cfg.removeEntry( QString::number(nFiles));
+      cfg.writeEntry("NumberofFiles", nFiles-1);
+      cfg.write();
+
+      ListView1->takeItem( ListView1->currentItem() );
+      //        ListView1->takeItem( ListView1->itemAt(nFiles) );
+      delete ListView1->currentItem();
+
+      ListView1->clear();
+      ListView1->setSelected(ListView1->firstChild(), true);
+      initIconView();
+      update();
+   }
+#ifndef DEV_VERSION
+   };
+#endif
+   setCaption( tr( "QpeRecord " ) + QString::number(VERSION) );
+
+}
+
+void QtRec::keyPressEvent( QKeyEvent *e) {
+
+   switch ( e->key() ) {
+      /*
+        vercel keys->
+        right side
+        0
+        1 0x1030 Key_F1
+        2 0x1031 Key_F2
+        3 0x1032 Key_F3
+        4 0x1016 Key_PageUp
+        5 0x1017 Key_PageDown
+        6
+        ---------------
+        left side
+        Up 0x1013 Key_Up
+        Down 0x1015 Key_Down
+        Left 0x1012 Key_Left
+        Right 0x1014 Key_Right
+        0x1010 Key_Home
+
+      */
+      //  case Key_F1:
+      //     if(stopped && !recording)
+      //       newSound();
+      //     else
+      //       stop();
+      //    break;
+      //   case Key_F2: {
+      //     if( !e->isAutoRepeat())
+      //     rewindPressed();
+      //   }
+      //     break;
+      //   case Key_F3: {
+      //     if( !e->isAutoRepeat())
+      //     FastforwardPressed();
+      //   }
+      //     break;
+
+      ////////////////////////////// Zaurus keys
+   case Key_F9: //activity
+      break;
+   case Key_F10: //contacts
+      break;
+   case Key_F11: //menu
+      break;
+   case Key_F12: //home
+      break;
+   case Key_F13: //mail
+      break;
+   case Key_Space:
+      break;
+   case Key_Delete:
+      break;
+   case Key_Up:
+      //    stop();
+      break;
+   case Key_Down:
+      //    newSound();
+      break;
+   case Key_Left: {
+      qDebug("rewinding");
+      if( !e->isAutoRepeat())
+         rewindPressed();
+   }
+      break;
+   case Key_Right: {
+      if( !e->isAutoRepeat())
+         FastforwardPressed();
+   }
+      break;
+   }
+}
+
+void  QtRec::keyReleaseEvent( QKeyEvent *e) {
+   switch ( e->key() ) {
+      //   case Key_F1:
+      //      if(stopped && !recording)
+      //        newSound();
+      //      else
+      //        stop();
+      //     break;
+      //   case Key_F2:
+      //     rewindReleased();
+      //     break;
+      //   case Key_F3:
+      //     FastforwardReleased();
+      //     break;
+
+      ////////////////////////////// Zaurus keys
+   case Key_F9: //activity
+      break;
+   case Key_F10: //contacts
+      break;
+   case Key_F11: //menu
+      break;
+   case Key_F12: //home
+      if(stopped)
+         doPlayBtn();
+      else
+         stop();
+      break;
+   case Key_F13: //mail
+      break;
+   case Key_Space:
+      if(stopped && !recording)
+         newSound();
+      else
+         stop();
+      break;
+   case Key_Delete:
+      deleteSound();
+      break;
+   case Key_Up:
+      //      stop();
+      qDebug("Up");
+      break;
+   case Key_Down:
+      //      start();
+      //      qDebug("Down");
+      //    newSound();
+      break;
+   case Key_Left:
+      qDebug("Left");
+      rewindReleased();
+      break;
+   case Key_Right:
+      qDebug("Right");
+      FastforwardReleased();
+      break;
+   }
+}
+
+void QtRec::endRecording() {
+   qDebug("endRecording");
+   setRecordButton(false);
+   timeSlider->setValue(0);
+   toBeginningButton->setEnabled(true);
+   toEndButton->setEnabled(true);
+
+   monitoring=false;
+
+   killTimers();
+
+   if(autoMute)
+      doMute(true);
+
+   soundDevice->closeDevice( true);
+
+   recording = false;
+   stopped=true;
+   t->stop();
+
+   if( wavFile->track.isOpen()) {
+      wavFile->adjustHeaders( filePara.fd, filePara.numberSamples);
+      //    soundDevice->sd=-1;
+      filePara.numberSamples=0;
+      //      filePara.sd=-1;
+      wavFile->closeFile();
+      filePara.fd=0;
+
+      if(wavFile->isTempFile()) {
+// move tmp file to regular file
+         QString cmd;
+         cmd.sprintf("mv "+ wavFile->trackName() + " " + wavFile->currentFileName);
+         qDebug("moving tmp file to "+currentFileName);
+         system(cmd.latin1());
+      }
+
+      qDebug("Just moved "+wavFile->currentFileName);
+      Config cfg("QpeRec");
+      cfg.setGroup("Sounds");
+
+      int nFiles = cfg.readNumEntry( "NumberofFiles",0);
+
+      currentFile = QFileInfo(wavFile->currentFileName).fileName();
+      currentFile=currentFile.left(currentFile.length()-4);
+
+      cfg.writeEntry( "NumberofFiles",nFiles+1);
+      cfg.writeEntry( QString::number( nFiles+1), currentFile);
+      cfg.writeEntry( currentFile, wavFile->currentFileName);
+
+      QString time;
+      time.sprintf("%.2f", filePara.numberOfRecordedSeconds);
+      cfg.writeEntry( wavFile->currentFileName, time );
+      qDebug("writing config numberOfRecordedSeconds "+time);
+
+      cfg.write();
+      qDebug("finished recording");
+      timeLabel->setText("");
+   }
+
+   if(soundDevice) delete soundDevice;
+
+   initIconView();
+   selectItemByName(currentFile);
+}
+
+void QtRec::endPlaying() {
+
+   qDebug("end playing");
+   setRecordButton(false);
+
+   toBeginningButton->setEnabled(true);
+   toEndButton->setEnabled(true);
+
+   if(autoMute)
+      doMute(true);
+
+   soundDevice->closeDevice( false);
+   soundDevice->sd=-1;
+   //  if(soundDevice) delete soundDevice;
+   qDebug("file and sound device closed");
+   stopped=true;
+   recording=false;
+   playing=false;
+   timeLabel->setText("");
+   monitoring=false;
+   total = 0;
+   filePara.numberSamples=0;
+   filePara.sd=-1;
+   wavFile->closeFile();
+   filePara.fd=0;
+//  if(wavFile) delete wavFile; //this crashes
+
+   qDebug("track closed");
+   timeSlider->setValue(0);
+
+   if(soundDevice) delete soundDevice;
+
+}
+
+bool QtRec::openPlayFile() {
+
+   qApp->processEvents();
+   if( currentFile.isEmpty()) {
+      QMessageBox::message(tr("Qperec"),tr("Please select file to  play"));
+      endPlaying();
+      return false;
+   }
+   QString currentFileName;
+   Config cfg("QpeRec");
+   cfg.setGroup("Sounds");
+   int nFiles = cfg.readNumEntry("NumberofFiles",0);
+   for(int i=0;i<nFiles+1;i++) { //look for file
+      if( cfg.readEntry( QString::number(i),"").find( currentFile,0,true) != -1) {
+         currentFileName=cfg.readEntry( currentFile, "" );
+         qDebug("opening for play: "+currentFileName);
+      }
+   }
+   wavFile = new WavFile(this,
+                         currentFileName,
+                         false);
+   filePara.fd = wavFile->wavHandle();
+   if(filePara.fd == -1) {
+      //  if(!track.open(IO_ReadOnly)) {
+      QString errorMsg=(QString)strerror(errno);
+      monitoring=false;
+      setCaption( tr( "QpeRecord " ) + QString::number(VERSION) );
+      QMessageBox::message(tr("Note"),tr("Could not open audio file.\n")
+                           +errorMsg+"\n"+currentFile);
+      return false;
+   } else {
+      filePara.numberSamples=wavFile->getNumberSamples();
+      filePara.format = wavFile->getFormat();
+      //      qDebug("file %d, samples %f", filePara.fd, filePara.numberSamples);
+      filePara.sampleRate= wavFile->getSampleRate();
+      filePara.resolution=wavFile->getResolution();
+      timeSlider->setPageStep(1);
+      monitoring=true;
+      timeSlider->setRange(0, filePara.numberSamples );
+      filePara.numberOfRecordedSeconds=(float) filePara.numberSamples / (float)filePara.sampleRate * (float)2;
+   }
+
+   return true;
+}
+
+void QtRec::listPressed( int mouse, QListViewItem *item, const QPoint &, int ) {
+   if(item == NULL )
+      return;
+   switch (mouse) {
+   case 1: {
+      if( renameBox !=0 ) //tricky
+         cancelRename();
+
+      currentFile=item->text(0);
+      setCaption( "QpeRecord  "+currentFile);
+   }
+      break;
+   case 2:
+      showListMenu(item);
+      ListView1->clearSelection();
+      break;
+   };
+}
+
+void QtRec::showListMenu(QListViewItem * item) {
+   if(item == NULL)
+      return;
+   QPopupMenu *m = new QPopupMenu(this);
+   m->insertItem( tr("Play"), this, SLOT( doMenuPlay() ));
+   if(Ir::supported())  m->insertItem( tr( "Send with Ir" ), this, SLOT( doBeam() ));
+   m->insertItem( tr( "Rename" ), this, SLOT( doRename() ));
+   // #if defined (QTOPIA_INTERNAL_FSLP)
+   //     m->insertItem( tr( "Properties" ), this, SLOT( doProperties() ));
+   // #endif
+   m->insertSeparator();
+   m->insertItem( tr("Delete"), this, SLOT( deleteSound() ) );
+   m->exec( QCursor::pos() );
+   qApp->processEvents();
+}
+
+void QtRec::fileBeamFinished( Ir *ir) {
+   if(ir)
+      QMessageBox::message( tr("Ir Beam out"), tr("Ir sent.") ,tr("Ok") );
+
+}
+
+void QtRec::doBeam() {
+   qApp->processEvents();
+   if(  ListView1->currentItem() == NULL)
+      return;
+   Ir ir;
+   if( ir.supported()) {
+      QString file = ListView1->currentItem()->text(0);
+      Config cfg("QpeRec");
+      cfg.setGroup("Sounds");
+
+      int nFiles = cfg.readNumEntry("NumberofFiles",0);
+
+      for(int i=0;i<nFiles+1;i++) {
+         if( cfg.readEntry( QString::number(i),"").find(file,0,true) != -1) {
+            QString filePath = cfg.readEntry(file,"");
+            Ir *file = new Ir(this, "IR");
+            connect(file, SIGNAL(done(Ir*)), this, SLOT( fileBeamFinished( Ir * )));
+            file->send( filePath, "QpeRec audio file\n"+filePath );
+         }
+      }
+   }
+}
+
+void QtRec::doMenuPlay() {
+   qApp->processEvents();
+   currentFile = ListView1->currentItem()->text(0);
+}
+
+void QtRec::doRename() {
+   QRect r = ListView1->itemRect( ListView1->currentItem( ));
+   r = QRect( ListView1->viewportToContents( r.topLeft() ), r.size() );
+   r.setX( ListView1->contentsX() );
+   if ( r.width() > ListView1->visibleWidth() )
+      r.setWidth( ListView1->visibleWidth() );
+
+   renameBox = new QLineEdit( ListView1->viewport(), "qt_renamebox" );
+   renameBox->setFrame(true);
+
+   renameBox->setText(  ListView1->currentItem()->text(0) );
+
+   renameBox->selectAll();
+   renameBox->installEventFilter( this );
+   ListView1->addChild( renameBox, r.x(), r.y() );
+   renameBox->resize( r.size() );
+   ListView1->viewport()->setFocusProxy( renameBox );
+   renameBox->setFocus();
+   renameBox->show();
+
+}
+
+void QtRec::okRename() {
+   qDebug("okRename");
+   qDebug(renameBox->text());
+   QString  filename = renameBox->text();
+   cancelRename();
+
+   if(  ListView1->currentItem() == NULL)
+      return;
+
+   Config cfg("QpeRec");
+   cfg.setGroup("Sounds");
+
+   QString file = ListView1->currentItem()->text(0);
+
+   qDebug("filename is  " + filename);
+
+   int nFiles = cfg.readNumEntry("NumberofFiles",0);
+
+   for(int i=0;i<nFiles+1;i++) { //look for file
+      if( cfg.readEntry( QString::number(i),"").find(file,0,true) != -1) {
+
+         QString filePath = cfg.readEntry(file,"");
+
+         cfg.writeEntry( QString::number(i), filename );
+         cfg.writeEntry( filename, filePath );
+         cfg.removeEntry(file);
+         cfg.write();
+      }
+   }
+
+   ListView1->takeItem( ListView1->currentItem() );
+   delete ListView1->currentItem();
+   ListView1->clear();
+   initIconView();
+   update();
+}
+
+void QtRec::cancelRename() {
+   qDebug("cancel rename");
+   bool resetFocus = ListView1->viewport()->focusProxy() == renameBox;
+   delete renameBox;
+   renameBox = 0;
+   if ( resetFocus ) {
+      ListView1->viewport()->setFocusProxy( ListView1 );
+      ListView1->setFocus();
+   }
+}
+
+bool QtRec::eventFilter( QObject * o, QEvent * e ) {
+   if ( o->inherits( "QLineEdit" ) ) {
+      if ( e->type() == QEvent::KeyPress ) {
+         QKeyEvent *ke = (QKeyEvent*)e;
+         if ( ke->key() == Key_Return ||
+              ke->key() == Key_Enter ) {
+            okRename();
+            return true;
+         } else if ( ke->key() == Key_Escape ) {
+            cancelRename();
+            return true;
+         }
+      } else if ( e->type() == QEvent::FocusOut ) {
+         cancelRename();
+         return true;
+      }
+   }
+   return QWidget::eventFilter( o, e );
+}
+
+
+int QtRec::getCurrentSizeLimit() {
+   return  sizeLimitCombo->currentItem() * 5;
+}
+
+void QtRec::timerBreak() {
+   qDebug("timer break");
+   stop();
+}
+
+void QtRec::doVolMuting(bool b) {
+   Config cfg( "qpe" );
+   cfg. setGroup( "Volume" );
+   cfg.writeEntry( "Mute",b);
+   cfg.write();
+   QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << b;
+}
+
+void QtRec::doMicMuting(bool b) {
+   //  qDebug("mic mute");
+   Config cfg( "qpe" );
+   cfg. setGroup( "Volume" );
+   cfg.writeEntry( "MicMute",b);
+   cfg.write();
+   QCopEnvelope( "QPE/System", "micChange(bool)" ) << b;
+}
+
+void QtRec::compressionSelected(bool b) {
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   cfg.writeEntry("wavCompression", b);
+   cfg.writeEntry("bitrate",16); filePara.resolution=16;
+   cfg.write();
+
+   if(b) {
+      bitRateComboBox->setEnabled(false);
+      bitRateComboBox->setCurrentItem(0);
+      filePara.resolution=16;
+   } else{
+      bitRateComboBox->setEnabled(true);
+   }
+}
+
+long QtRec::checkDiskSpace(const QString &path) {
+
+   struct statfs fs;
+
+   if ( !statfs( path.latin1(), &fs ) ) {
+
+      int blkSize = fs.f_bsize;
+      int availBlks = fs.f_bavail;
+
+      long mult = blkSize / 1024;
+      long div = 1024 / blkSize;
+
+      if ( !mult ) mult = 1;
+      if ( !div ) div = 1;
+
+      return  availBlks * mult / div;
+   }
+   return -1;
+}
+
+//   short  f_fstyp;    /* File system type */
+//   long  f_bsize;    /* Block size */
+//   long  f_frsize;   /* Fragment size */
+//   long  f_blocks;   /* Total number of blocks*/
+//   long  f_bfree;    /* Count of free blocks */
+//   long  f_files;    /* Total number of file nodes */
+//   long  f_ffree;    /* Count of free file nodes */
+//   char  f_fname[6]; /* Volumename */
+//   char  f_fpack[6]; /* Pack name */
+
+void QtRec::receive( const QCString &msg, const QByteArray & ) {
+   qDebug("Voicerecord received message "+msg);
+
+}
+
+
+///////////////////////////// timerEvent
+void QtRec::timerEvent( QTimerEvent *e ) {
+//   qDebug( "%d", secCount );
+#ifdef DEV_VERSION
+   QString msg;
+   msg.sprintf("%d, %d, %d", filePara.sampleRate, filePara.channels, filePara.resolution);
+   setCaption( msg +" ::  "+QString::number(secCount));    
+#endif
+
+   if( !playing ) {
+      if(!recording ){
+         killTimer(e->timerId());
+///*      stopped=true;
+//      recording=false;
+///*/
+//              _exit( 0);
+      }
+      if(filePara.SecondsToRecord < secCount && filePara.SecondsToRecord !=0) {
+         killTimer(e->timerId());
+         stop();
+      }
+   }
+//    if( stopped && !paused) {
+//        if( filePara.numberOfRecordedSeconds < secCount) {
+//            stopped = true;
+// //           playing=false;
+//            killTimer(e->timerId());
+//            endPlaying();
+//        }
+//    }
+//  qApp->processEvents();
+   secCount++;
+}
+
+void QtRec::changeTimeSlider(int index) {
+   if(ListView1->currentItem() == 0 || !wavFile->track.isOpen()) return;
+   //  qDebug("Slider moved to %d",index);
+   paused = true;
+   stopped = true;
+
+   sliderPos=index;
+
+   QString timeString;
+   filePara.numberOfRecordedSeconds=(float)sliderPos/(float)filePara.sampleRate*(float)2;
+   timeString.sprintf( "%.2f", filePara.numberOfRecordedSeconds);
+   secCount = (int)filePara.numberOfRecordedSeconds;
+   timeLabel->setText( timeString+ tr(" seconds"));
+}
+
+void QtRec::timeSliderPressed() {
+   if(ListView1->currentItem() == 0) return;
+   //  qDebug("slider pressed");
+   paused = true;
+   stopped = true;
+}
+
+void QtRec::timeSliderReleased() {
+   if(ListView1->currentItem() == 0) return;
+   sliderPos=timeSlider->value();
+
+   //  qDebug("slider released %d", sliderPos);
+   stopped = false;
+   int newPos =  lseek( filePara.fd, sliderPos, SEEK_SET);
+   total =  newPos*4;
+   filePara.numberOfRecordedSeconds=(float)sliderPos/(float)filePara.sampleRate*(float)2;
+
+   doPlay();
+}
+
+void QtRec::rewindPressed() {
+   if(ListView1->currentItem() == 0) return;
+   if( !wavFile->track.isOpen()) {
+      if( !openPlayFile() )
+         return;
+      else
+         if( !setupAudio( false))
+            return;
+   } else {
+      killTimers();
+      paused = true;
+      stopped = true;
+      rewindTimer->start(50, false);
+   }
+}
+
+void QtRec::rewindTimerTimeout() {
+   int  sliderValue = timeSlider->value();
+   sliderValue = sliderValue-(filePara.numberSamples/100);
+   //  if(toBeginningButton->isDown())
+   timeSlider->setValue( sliderValue ) ;
+   //  qDebug("%d", sliderValue);
+   QString timeString;
+   filePara.numberOfRecordedSeconds=(float)sliderValue/(float)filePara.sampleRate*(float)2;
+   timeString.sprintf( "%.2f", filePara.numberOfRecordedSeconds);
+   timeLabel->setText( timeString+ tr(" seconds"));
+}
+
+void QtRec::rewindReleased() {
+   rewindTimer->stop();
+   if( wavFile->track.isOpen()) {
+      sliderPos=timeSlider->value();
+      stopped = false;
+      int newPos =  lseek( filePara.fd, sliderPos, SEEK_SET);
+      total =  newPos*4;
+      //    qDebug("rewind released %d", total);
+      startTimer(1000);
+      doPlay();
+   }
+}
+
+void QtRec::FastforwardPressed() {
+   if(ListView1->currentItem() == 0) return;
+   if( !wavFile->track.isOpen())
+      if( !openPlayFile() )
+         return;
+      else
+         if( !setupAudio( false))
+            return;
+   killTimers();
+
+   paused = true;
+   stopped = true;
+   forwardTimer->start(50, false);
+}
+
+
+void QtRec::forwardTimerTimeout() {
+   int sliderValue = timeSlider->value();
+   sliderValue = sliderValue +(filePara.numberSamples/100);
+
+   //  if(toEndButton->isDown())
+   timeSlider->setValue(sliderValue);
+
+   QString timeString;
+   filePara.numberOfRecordedSeconds=(float)sliderValue/(float)filePara.sampleRate*(float)2;
+   timeString.sprintf( "%.2f", filePara.numberOfRecordedSeconds);
+   timeLabel->setText( timeString+ tr(" seconds"));
+}
+
+void QtRec::FastforwardReleased() {
+   forwardTimer->stop();
+   if( wavFile->track.isOpen()) {
+      sliderPos=timeSlider->value();
+      stopped = false;
+      int newPos =  lseek( filePara.fd, sliderPos, SEEK_SET);
+      total =  newPos*4;
+      filePara.numberOfRecordedSeconds=(float)sliderPos/(float)filePara.sampleRate*(float)2;
+      startTimer(1000);
+      doPlay();
+   }
+}
+
+
+QString QtRec::getStorage(const QString &fileName) {
+
+   StorageInfo storageInfo;
+   const QList<FileSystem> &fs = storageInfo.fileSystems();
+   QListIterator<FileSystem> it ( fs );
+   QString storage;
+   for( ; it.current(); ++it ){
+      const QString name = (*it)->name();
+      const QString path = (*it)->path();
+      const QString disk = (*it)->disk();
+      if( fileName.find(path,0,true) != -1)
+         storage=name;
+      //        const QString options = (*it)->options();
+      //        if( name.find( tr("Internal"),0,true) == -1) {
+      //            storageComboBox->insertItem( name +" -> "+disk);
+      //    qDebug(name);
+   }
+   return storage;
+   //      struct mntent *me;
+   //  //     if(fileName == "/etc/mtab") {
+   //      FILE *mntfp = setmntent( fileName.latin1(), "r" );
+   //      if ( mntfp ) {
+   //          while ( (me = getmntent( mntfp )) != 0 ) {
+   //              QString filesystemType = me->mnt_type;
+
+   //          }
+   //      }
+   //      endmntent( mntfp );
+}
+
+void QtRec::setRecordButton(bool b) {
+
+   if(b) { //about to record or play
+
+      Rec_PushButton->setDown(true);
+      QPixmap image3( ( const char** ) image3_data );
+      Stop_PushButton->setPixmap( image3 );
+      if(Stop_PushButton->isDown())
+         Stop_PushButton->setDown(true);
+      playLabel2->setText("Stop");
+
+   } else { //about to stop
+
+      QPixmap image4( ( const char** ) image4_data );
+      Stop_PushButton->setPixmap( image4);
+      if(Stop_PushButton->isDown())
+         Stop_PushButton->setDown(false);
+      playLabel2->setText("Play");
+      if(Rec_PushButton->isDown())
+         Rec_PushButton->setDown( false);
+   }
+}
+
+void QtRec::fillDirectoryCombo() {
+   if( directoryComboBox->count() > 0)
+      directoryComboBox->clear();
+   int index=0;
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   QString dir= cfg.readEntry("directory", "/");
+   StorageInfo storageInfo;
+   const QList<FileSystem> &fs = storageInfo.fileSystems();
+   QListIterator<FileSystem> it ( fs );
+   QString storage;
+   for( ; it.current(); ++it ){
+      const QString name = (*it)->name();
+      const QString path = (*it)->path();
+      //    directoryComboBox->insertItem(name+" "+path);
+      directoryComboBox->insertItem(name);
+      if(path==dir)
+         directoryComboBox->setCurrentItem(index);
+      index++;
+   }
+}
+
+void QtRec::errorStop() {
+   stopped = true;
+   wavFile->closeFile();
+   killTimers();
+}
+
+void QtRec::doMute(bool b) {
+   doVolMuting( b);
+   doMicMuting( b);
+}
+
+void QtRec::slotAutoMute(bool b) {
+   autoMute=b;
+   Config cfg("QpeRec");
+   cfg.setGroup("Settings");
+   cfg.writeEntry("useAutoMute",b);
+   doMute(b);
+   outMuteCheckBox->setChecked( b);
+   inMuteCheckBox->setChecked( b);
+}
+
+void QtRec::selectItemByName(const QString & name) {
+   QListViewItemIterator it( ListView1 );
+   for ( ; it.current(); ++it )
+      if(name == it.current()->text(0))
+         ListView1->setCurrentItem(it.current());
+}
+
+
+long findPeak(long input ) {
+
+// halfLife = time in seconds for output to decay to half value after an impulse
+   static float output = 0.0;
+   int halfLife = .25;
+   float vsf = .0025;
+   float scalar = pow( 0.5, 1.0/(halfLife * filePara.sampleRate ));
+   if( input < 0.0 )
+      input = -input;  // Absolute value.
+   if ( input >= output )
+   {
+      // When we hit a peak, ride the peak to the top.
+      output = input;
+   }
+   else
+   {
+// Exponential decay of output when signal is low.
+      output = output * scalar;
+//  
+//   When current gets close to 0.0, set current to 0.0 to prevent FP underflow
+//   which can cause a severe performance degradation due to a flood
+//   of interrupts.
+//
+      if( output < vsf ) output = 0.0;
+   }
+
+   return output;
+}