summaryrefslogtreecommitdiff
path: root/noncore/multimedia/opierec/qtrec.cpp
Side-by-side diff
Diffstat (limited to 'noncore/multimedia/opierec/qtrec.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/multimedia/opierec/qtrec.cpp2270
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;
+}