add pdaudio stuff

5 files changed, 127 insertions, 47 deletions

diff --git a/noncore/multimedia/opierec/main.cpp b/noncore/multimedia/opierec/main.cpp
index e36d050..714907c 100644
--- a/noncore/multimedia/opierec/main.cpp
+++ b/noncore/multimedia/opierec/main.cpp
@@ -1,19 +1,30 @@
 /***************************************************************************
  main.cpp  -  main routine
  ***************************************************************************/
 //// main.cpp
 ////  copyright 2001, 2002, by L. J. Potter <ljp@llornkcor.com>
 /***************************************************************************
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 #include "qtrec.h"
 #include <qpe/qpeapplication.h>
-#include <opie/oapplicationfactory.h>
 
+#ifdef PDAUDIO
+int main(int argc, char* argv[]) {
+    QPEApplication a(argc, argv);
+    QtRec qtrec;
+    a.showMainWidget( &qtrec);
+ return a.exec();
+}
+
+
+#else
+#include <opie/oapplicationfactory.h>
 OPIE_EXPORT_APP( OApplicationFactory<QtRec> )
 
+#endif
 
 
diff --git a/noncore/multimedia/opierec/opierec.pro b/noncore/multimedia/opierec/opierec.pro
index b607c09..39fe493 100644
--- a/noncore/multimedia/opierec/opierec.pro
+++ b/noncore/multimedia/opierec/opierec.pro
@@ -1,26 +1,40 @@
-CONFIG   = qt warn_on release
+#CONFIG   = qt qtopia warn_on release pdaudio
+CONFIG   = qt warn_on release opie
 #CONFIG    = qt warn_on release quick-app
 HEADERS   = adpcm.h \
         pixmaps.h \
         helpwindow.h \
         qtrec.h \
         device.h \
         wavFile.h \
         waveform.h
 SOURCES   = adpcm.c \
         helpwindow.cpp \
         main.cpp \
         qtrec.cpp \
         device.cpp \
         wavFile.cpp \
         waveform.cpp
-INCLUDEPATH += $(OPIEDIR)/include
-DEPENDPATH  += $(OPIEDIR)/include
-#LIBS            += -L/opt/buildroot-opie/output/staging/target/lib -lqpe -lpthread -ljpeg -lpng -lz
-LIBS            += -lqpe -lpthread
 INTERFACES  =
-TARGET    = opierec
-DESTDIR=$(OPIEDIR)/bin
 
-include ( $(OPIEDIR)/include.pro )
+contains(CONFIG, pdaudio) {
+#  LIBS += -L/opt/buildroot-opie/output/staging/target/lib -lqpe -lpthread -ljpeg -lpng -lz
+  LIBS += -L$(QPEDIR)/lib -lqpe -lpthread -ljpeg -lpng -lz
+  INCLUDEPATH += $(QPEDIR)/include
+  DEPENDPATH  += $(QPEDIR)/include
+  DEFINES += PDAUDIO
+  TARGET    = qperec
+
+#  DESTDIR=$(QPEDIR)/bin
+}
+
+contains(CONFIG, opie) {
+  INCLUDEPATH += $(OPIEDIR)/include
+  DEPENDPATH  += $(OPIEDIR)/include
+  DESTDIR=$(OPIEDIR)/bin
+  LIBS            += -lqpe -lpthread
+  TARGET    = opierec
+  include ( $(OPIEDIR)/include.pro )
+}
+
 
diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
index aeab26d..bc6abcc 100644
--- a/noncore/multimedia/opierec/qtrec.cpp
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -35,48 +35,58 @@ extern "C" {
 #include <qlistview.h>
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qslider.h>
 #include <qtabwidget.h>
 #include <qtimer.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>
 
+
+#ifdef PDAUDIO //ALSA
+#include <alsa/asoundlib.h>
+static int deviceSampleRates[8] = { 32000, 44100, 48000, 88200, 96000, 176400, 192000, -1 };
+static int deviceBitRates[] = { 8, 16, 24, 32, -1 };
+#else //OSS
+static int deviceSampleRates[6] = { 11025, 16000, 22050, 32000, 44100, -1 };
+static int deviceBitRates[] = { 8, 16, -1 };
+#endif
+
 #if defined(QT_QWS_SL5XXX)
 ///#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
 
 //#define ZAURUS 0
 struct adpcm_state encoder_state;
 struct adpcm_state decoder_state;
 
 typedef struct {
    int sampleRate;
    /*      int fragSize; */
@@ -87,51 +97,51 @@ typedef struct {
    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, playing;
 bool stopped;
 QLabel *timeLabel;
 QSlider *timeSlider;
 int sd;
 
 Waveform* waveform;
 Device *soundDevice;
 
 // threaded recording
 //fuckin fulgy here
-void quickRec()
-{
-//void QtRec::quickRec() {
+//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;
 
    bytesWritten = 0;
    number = 0;
    QString num;
    int level = 0;
    int threshold = 0;
 //   int bits = filePara.resolution;
 //   qDebug("bits %d", bits);
 
    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;
 
@@ -142,89 +152,91 @@ void quickRec()
          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;
             }
 
 //             number=::read( filePara.sd, sbuf, BUFSIZE);
             number =  soundDevice ->devRead( filePara.sd, sbuf, BUFSIZE);
 
             if(number <= 0) {
                perror("recording error ");
                qDebug( "%s %d", filePara.fileName, number);
                stopped = true;
                return;
             }
             //if(stereo == 2) {
 //        adpcm_coder( sbuf2, abuf, number/2, &encoder_state);
             adpcm_coder( sbuf, abuf, number/2, &encoder_state);
-            bytesWritten = soundDevice->devWrite( filePara.fd , (short *)abuf, number/4);
-            waveform->newSamples( (const short *)abuf, bytesWritten );
+
+            bytesWritten = ::write( filePara.fd , (short *)abuf, number/4);
+
+                                                waveform->newSamples( (const short *)abuf, bytesWritten );
 
             total += bytesWritten;
             filePara.numberSamples = total;
             timeSlider->setValue( total);
 
             filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate * (float)2 / filePara.channels;
 
             qApp->processEvents();
             if( total >= filePara.samplesToRecord) {
                stopped = true;
                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");
                stopped = true;
                break;  // stop if playing was set to false
                return;
             }
 
-            number =  soundDevice ->devRead( filePara.sd, (short *)inbuffer, BUFSIZE);
+            number = soundDevice->devRead( filePara.sd, (short *)inbuffer, BUFSIZE);
             waveform->newSamples( inbuffer, number );
 
             if( number <= 0) {
                perror( "recording error ");
                qDebug( filePara.fileName);
                stopped = true;
                return;
             }
 
-            bytesWritten = soundDevice->devWrite( filePara.fd , inbuffer, number);
+            bytesWritten = ::write( filePara.fd , inbuffer, number);
 
             if( bytesWritten < 0) {
                perror("File writing error ");
                stopped = true;
                return;
             }
 
             total += bytesWritten;
 
             filePara.numberSamples = total;
 
             if( filePara.SecondsToRecord != 0)
                timeSlider->setValue( total);
 //         printf("Writing number %d, bytes %d,total %d\r",number,  bytesWritten , total);
 //         fflush(stdout);
 
             filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2/filePara.channels;
 
             qApp->processEvents();
 
             if( total >= filePara.samplesToRecord) {
                stopped = true;
                break;
          }
@@ -249,50 +261,51 @@ void quickRec()
             stopped = true;
             QMessageBox::message("Note","There was a problem\nwriting to the file");
             perror("File writing error ");
             return;
          }
 
          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;
 
          qApp->processEvents();
          if( total >= filePara.samplesToRecord) {
             stopped = true;
             break;
          }
       } //end main loop
    }
 } /// END quickRec()
 
+void QtRec::playIt()
 
-void playIt()
+//void playIt()
 {
    int bytesWritten, number;
    int total = 0;  // Total number of bytes read in so far.
    if( filePara.resolution == 16 ) { //AFMT_S16_LE) {
       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;
                return;
             }// 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];
 //                 }
@@ -548,91 +561,94 @@ void QtRec::init() {
    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" );
    QGridLayout *glayout3 = new QGridLayout( tab_3 );
    glayout3->setSpacing( 2);
    glayout3->setMargin( 2);
    ////////////////////////////////////
    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
+                QString s;
+                int z = 0;
+                while( deviceSampleRates[z] != -1) {
+                                sampleRateComboBox->insertItem( s.setNum( deviceSampleRates[z], 10));
+                                z++;
+                }
+
 
    glayout3->addMultiCellWidget(  sampleGroup, 0, 0, 0, 0);
 
    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));
    }
 
 
    glayout3->addMultiCellWidget(  sizeGroup, 0, 0, 1, 1);
    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 ) );
 
    glayout3->addMultiCellWidget(  dirGroup, 1, 1, 0, 0);
 
    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 ) );
+
+                z = 0;
+         while( deviceBitRates[z] != -1) {
+                                bitRateComboBox->insertItem( s.setNum( deviceBitRates[z], 10) );
+                                z++;
+                }
+
+                bitRateComboBox->setGeometry( QRect( 5, 20, 50, 25 ) );
 
    glayout3->addMultiCellWidget(  bitGroup, 1, 1, 1, 1);
 
    compressionCheckBox = new QCheckBox ( tr("Wave Compression (smaller files)"), tab_3 );
 
    autoMuteCheckBox = new QCheckBox ( tr("Auto Mute"), tab_3 );
    stereoCheckBox = new QCheckBox ( tr("Stereo Channels"), tab_3 );
 
    glayout3->addMultiCellWidget( compressionCheckBox, 2, 2, 0, 3);
    glayout3->addMultiCellWidget( autoMuteCheckBox, 3, 3, 0, 0);
    glayout3->addMultiCellWidget( stereoCheckBox, 3, 3, 1, 1);
 
    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 );
@@ -823,52 +839,57 @@ void QtRec::initConnections() {
             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("OpieRec");
    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);
+                if(i == 16)
+                                bitRateComboBox->setCurrentItem( 1);
+                        elseif(i == 24)
+                                bitRateComboBox->setCurrentItem( 2);
+                        elseif(i == 32)
+                                bitRateComboBox->setCurrentItem( 3);
+                else
+                                bitRateComboBox->setCurrentItem( 0);
+
    filePara.resolution = i;
 
    i = cfg.readNumEntry("sizeLimit", 5 );
    QString temp;
    sizeLimitCombo->setCurrentItem((i/5));
 
    stereoCheckBox->setChecked( cfg.readBoolEntry("stereo", 1));
    if( stereoCheckBox->isChecked()) {
       filePara.channels = 2;
    } else {
       filePara.channels = 1;
    }
 
    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
@@ -969,55 +990,55 @@ bool QtRec::rec() { //record
             }
             //                  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");
                stopped = false;
 
-                pthread_t thread1;
-                pthread_create( &thread1, NULL, (void * (*)(void *))quickRec, NULL/* &*/);
+//                 pthread_t thread1;
+//                 pthread_create( &thread1, NULL, (void * (*)(void *))quickRec, NULL/* &*/);
                toBeginningButton->setEnabled( false);
                toEndButton->setEnabled( false);
 
                startTimer(1000);
-//               quickRec();
+               quickRec();
             }
          } //end setUpFile
    } //end setupAudio
    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();
@@ -1032,79 +1053,108 @@ void QtRec::getOutVol( ) {
 }
 
 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
 
+#ifdef PDAUDIO //ALSA
+                if( !b) { // we want to play
+                                if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
+                                                sampleformat = SND_PCM_FORMAT_S16;
+                                                filePara.resolution = 16;
+                                } else if( filePara.resolution == 24 || compressionCheckBox->isChecked() ) {
+                                                sampleformat = SND_PCM_FORMAT_S24;
+                                                filePara.resolution = 24;
+                                } else if( filePara.resolution == 32 || compressionCheckBox->isChecked() ) {
+                                                sampleformat = SND_PCM_FORMAT_S32;
+                                                filePara.resolution = 32;
+                                } else {
+                                                sampleformat = SND_PCM_FORMAT_U8;
+                                                filePara.resolution = 8;
+                                }
+#else
    if( !b) {
 // we want to play
       if( filePara.resolution == 16 || compressionCheckBox->isChecked() ) {
          sampleformat = AFMT_S16_LE;
          filePara.resolution = 16;
       } else {
          sampleformat = AFMT_U8;
          filePara.resolution = 8;
       }
-
+#endif
+                        
       stereo = filePara.channels;
       flags = O_WRONLY;
       dspString = DSPSTROUT;
       mixerString = DSPSTRMIXEROUT;
       recording = false;
    } else { // we want to record
 
-      if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
+#ifdef PDAUDIO //ALSA
+                                if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "16")
+                                                sampleformat = SND_PCM_FORMAT_S16;
+                                else if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "24")
+                                                sampleformat = SND_PCM_FORMAT_S24;
+                                else if( !bitRateComboBox->isEnabled() || bitRateComboBox->currentText() == "32")
+                                                sampleformat = SND_PCM_FORMAT_S32;
+                                else
+                                                sampleformat = SND_PCM_FORMAT_U8;
+
+#else
+                         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");
       }
-
+#endif
+                        
       stereo = filePara.channels;
 //        filePara.sampleRate = sampleRateComboBox->currentText().toInt( &ok,10);//44100;
       flags= O_RDWR;
 //        flags= O_RDONLY;
       dspString = DSPSTRIN;
       mixerString = DSPSTRMIXEROUT;
       recording = true;
    }
 
    // if(soundDevice) delete soundDevice;
    qDebug("<<<<<<<<<<<<<<<<<<<open dsp %d %d %d", filePara.sampleRate, filePara.channels, sampleformat);
    qWarning("change waveform settings");
    waveform->changeSettings( filePara.sampleRate, filePara.channels );
 
    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);
@@ -1162,64 +1212,67 @@ bool QtRec::doPlay() {
       secCount = (int)filePara.numberOfRecordedSeconds;
    }
    playing = true;
    stopped = false;
    recording = false;
 
    QString num;
    qDebug( "Play number of samples %d", filePara.numberSamples);
 
 //   timeSlider->setRange( 0, filePara.numberSamples);
 
    timeString.sprintf("%d",  filePara.numberOfRecordedSeconds);
    timeLabel->setText( timeString+ tr(" seconds"));
 
    QString msg;
    msg.sprintf("%d, %d, %d",
                filePara.sampleRate,
                filePara.channels,
                filePara.resolution);
 #ifdef DEV_VERSION
    setCaption( msg);
 #endif
 
     startTimer( 1000);
-    pthread_t thread2;
-    pthread_create( &thread2, NULL, (void * (*)(void *))playIt, NULL/* &*/);
+//     pthread_t thread2;
+//     pthread_create( &thread2, NULL, (void * (*)(void *))playIt, NULL/* &*/);
 
     toBeginningButton->setEnabled( false);
     toEndButton->setEnabled( false);
+                playIt();
 
    return true;
 }
 
 
 void QtRec::changebitrateCombo(int i) {
    Config cfg("OpieRec");
    cfg.setGroup("Settings");
    int bits = 0;
-   if( i == 0) { bits = 16; }
-   else { bits=8; }
+                if( i == 1) { bits = 16; }
+                else if( i == 2) { bits = 24; }
+                else if( i == 3) { bits = 32; }
+                else { bits=8; }
    cfg.writeEntry("bitrate", bits);
    filePara.resolution = bits;
    cfg.write();
 }
 
 void QtRec::changesamplerateCombo(int i) {
    Config cfg("OpieRec");
    cfg.setGroup("Settings");
    int rate=0;
    bool ok;
    rate = sampleRateComboBox->text(i).toInt(&ok, 10);
    cfg.writeEntry( "samplerate",rate);
    filePara.sampleRate=rate;
    qDebug( "Change sample rate %d", rate);
    cfg.write();
 }
 
 
 void QtRec::changeDirCombo(int index) {
    Config cfg("OpieRec");
    cfg.setGroup("Settings");
    QString sName = directoryComboBox->text(index);
 
    StorageInfo storageInfo;
diff --git a/noncore/multimedia/opierec/qtrec.h b/noncore/multimedia/opierec/qtrec.h
index 93b9b5f..31cff9e 100644
--- a/noncore/multimedia/opierec/qtrec.h
+++ b/noncore/multimedia/opierec/qtrec.h
@@ -1,31 +1,31 @@
 /****************************************************************************
  ** Created: Thu Jan 17 11:19:45 2002
 copyright 2002 by L.J. Potter ljp@llornkcor.com
 ****************************************************************************/
 #ifndef QTREC_H
 #define QTREC_H
-#define VERSION 20030920
+#define VERSION 20040101
 
 #include <qpe/ir.h>
 
 #include <qfile.h>
 #include <qimage.h>
 #include <qlineedit.h>
 #include <qpixmap.h>
 #include <qvariant.h>
 #include <qwidget.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "device.h"
 #include "wavFile.h"
 
 class QButtonGroup;
 class QCheckBox;
 class QComboBox;
 class QGridLayout; 
 class QGroupBox;
 class QHBoxLayout; 
 class QIconView;
 class QIconViewItem;
 class QLabel;
@@ -156,29 +156,30 @@ protected:
    QVBoxLayout* Layout15;
    QVBoxLayout* Layout15b;
    QVBoxLayout* Layout18;
    QWidget *tab, *tab_2, *tab_3, *tab_4, *tab_5;
    int sliderPos, total;
 //    short inbuffer[BUFSIZE], outbuffer[BUFSIZE];
 //    unsigned short unsigned_inbuffer[BUFSIZE], unsigned_outbuffer[BUFSIZE];
    QGroupBox *sampleGroup, *bitGroup, *dirGroup, *sizeGroup;
 /*     short inbuffer[65536], outbuffer[65536]; */
 /*     unsigned short unsigned_inbuffer[65536], unsigned_outbuffer[65536]; */
 
 
    bool doPlay();
    bool openPlayFile();
    bool setUpFile();
    bool setupAudio( bool b);
    void endPlaying();
    void endRecording();
    void fileBeamFinished( Ir *ir);
    void initIconView();
    void keyPressEvent( QKeyEvent *e);
    void keyReleaseEvent( QKeyEvent *e);
    void receive( const QCString &, const QByteArray & );
    void showListMenu(QListViewItem * );
-//   void quickRec();
-    
+   void quickRec();
+         void playIt();
+  
 };
 
 #endif // QTREC_H
diff --git a/noncore/multimedia/opierec/wavFile.cpp b/noncore/multimedia/opierec/wavFile.cpp
index 987fa32..1d58bb3 100644
--- a/noncore/multimedia/opierec/wavFile.cpp
+++ b/noncore/multimedia/opierec/wavFile.cpp
@@ -26,49 +26,50 @@ WavFile::WavFile( QObject * parent,const QString &fileName, bool makeNwFile, int
         : QObject( parent)
 {
 //qDebug("new wave file");
     bool b =  makeNwFile;
     wavSampleRate=sampleRate;
     wavFormat=format;
     wavChannels=channels;
     wavResolution=resolution;
     useTmpFile=false;
     if( b) {
         newFile();
     } else {
         openFile(fileName);
     }
 }
 
 bool WavFile::newFile() {
 
 //  qDebug("Set up new file");
   Config cfg("OpieRec");
   cfg.setGroup("Settings");
 
   currentFileName=cfg.readEntry("directory",QDir::homeDirPath());
   QString date;
-  date = TimeString::dateString( QDateTime::currentDateTime(),false,true);
+  QDateTime dt = QDateTime::currentDateTime();
+  date = dt.toString();//TimeString::dateString( QDateTime::currentDateTime(),false,true);
   date.replace(QRegExp("'"),"");
   date.replace(QRegExp(" "),"_");
   date.replace(QRegExp(":"),".");
   date.replace(QRegExp(","),"");
 
   QString currentFile=date;
   if(currentFileName.right(1).find("/",0,true) == -1)
     currentFileName += "/" + date;
   else
     currentFileName += date;
   currentFileName+=".wav";
 
 //  qDebug("set up file for recording: "+currentFileName);
   char pointer[] = "/tmp/opierec-XXXXXX";
   int fd = 0;
 
   if( currentFileName.find("/mnt",0,true) == -1
       && currentFileName.find("/tmp",0,true) == -1 ) {
     // if destination file is most likely in flash (assuming jffs2)
     // we have to write to a different filesystem first
         
     useTmpFile = true;
     if(( fd = mkstemp( pointer)) < 0 ) {
        perror("mkstemp failed");