use openzaurus dsp

1 files changed, 7 insertions, 1 deletions

diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
index e3385cd..1141faa 100644
--- a/noncore/multimedia/opierec/qtrec.cpp
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -1,264 +1,270 @@
 /****************************************************************************
          // 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 "waveform.h"
 extern "C" {
 #include "adpcm.h"
 }
 
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/config.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 using namespace Opie::Core;
 
 /* QT */
 #include <qcheckbox.h>
 #include <qcombobox.h>
 #include <qdir.h>
 #include <qgroupbox.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlistview.h>
 #include <qmessagebox.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qslider.h>
 #include <qtabwidget.h>
 #include <qtimer.h>
 
 /* STD */
 #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>
 #include <pthread.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"
+
+#ifdef SHARP
+#define DSPSTRIN "/dev/dsp1"
 #define DSPSTRMIXERIN "/dev/mixer1"
+#else
+#define DSPSTRIN "/dev/dsp"
+#define DSPSTRMIXERIN "/dev/mixer"
+#endif
 
 #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; */
                         /*      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, playing;
 bool stopped;
 QLabel *timeLabel;
 QSlider *timeSlider;
 int sd;
 
 Waveform* waveform;
 Device *soundDevice;
 
 
 #ifdef THREADED
 void quickRec()
 #else
                 void QtRec::quickRec()
 #endif
 {
 
                 odebug << ( filePara.numberSamples/filePara.sampleRate * filePara.channels ) << oendl;
                 odebug << "samples " << filePara.numberSamples << ", rate " << filePara.sampleRate
                                          << ", channels " << filePara.channels << oendl;
 
                 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;
    odebug << "bits " << bits << "" << oendl;
 
                 if( filePara.resolution == 16 ) { //AFMT_S16_LE)
        odebug << "AFMT_S16_LE size " << filePara.SecondsToRecord << "" << oendl;
        odebug << "samples to record " << filePara.samplesToRecord << "" << oendl;
        odebug << "" << filePara.sd << "" << oendl;
                                 level = 7;
                                 threshold = 0;
 
                                 if( filePara.format == WAVE_FORMAT_DVI_ADPCM) {
           odebug << "start recording WAVE_FORMAT_DVI_ADPCM" << oendl;
 // <<<<<<<<<<<<<<<<<<<<<<<<<<<  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) {
                                                                                 odebug << "quickRec:: stopped" << oendl;
                                                                                 break;
                                                                 }
 
 //             number=::read( filePara.sd, sbuf, BUFSIZE);
                                                                 number =  soundDevice->devRead( filePara.sd, sbuf, BUFSIZE);
 
                                                                 if(number <= 0) {
                                                                                 perror("recording error ");
                                                                                 odebug << "" << filePara.fileName << " " << number << "" << oendl;
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
                                                                         //if(stereo == 2) {
 //        adpcm_coder( sbuf2, abuf, number/2, &encoder_state);
                                                                 adpcm_coder( sbuf, abuf, number/2, &encoder_state);
 
                                                                 bytesWritten = ::write( filePara.fd , (short *)abuf, number/4);
 
                                                                 waveform->newSamples( sbuf, number );
 
                                                                 total += bytesWritten;
                                                                 filePara.numberSamples = total;
                                                                 timeSlider->setValue( total);
 
          printf("%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;
                                                                 }
                                                 }
                                 } else {
                                                         // <<<<<<<<<<<<<<<<<<<<<<<<<<<  WAVE_FORMAT_PCM   >>>>>>>>>>>>>>>>>>>>>>
                                                 odebug << "start recording WAVE_FORMAT_PCM" << oendl;
                                                 short inbuffer[ BUFSIZE ], outbuffer[ BUFSIZE ];
                                                 memset( inbuffer, 0, BUFSIZE);
                                                 memset( outbuffer, 0, BUFSIZE);
 
                                                 for(;;) {
                                                                 if ( stopped) {
                                                                                 odebug << "quickRec:: stopped" << oendl;
                                                                                 stopped = true;
                                                                                 break;  // stop if playing was set to false
                                                                                 return;
                                                                 }
 
                                                                 number = soundDevice->devRead( soundDevice->sd /*filePara.sd*/, (short *)inbuffer, BUFSIZE);
 
                                                                 if( number <= 0) {
                                                                                 perror( "recording error ");
                                                                                 odebug << filePara.fileName << oendl;
                                                                                 stopped = true;
                                                                                 return;
                                                                 }
 
                                                                 bytesWritten = ::write( filePara.fd , inbuffer, number);
                                                                 waveform->newSamples( 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("%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;
                                                                 }
                                                 }
                                 } //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) {
                                                                 odebug << "quickRec:: stopped" << oendl;
                                                                 break;  // stop if playing was set to false
                                                 }
 
                                                 number = ::read( soundDevice->sd /*filePara.sd*/ , unsigned_inbuffer, BUFSIZE);
                                                 bytesWritten = ::write( filePara.fd , unsigned_inbuffer, number);
             waveform->newSamples( (const short *) unsigned_inbuffer, number );
 
                                                 if(bytesWritten < 0) {
                                                                 stopped = true;