summaryrefslogtreecommitdiff
authorschurig <schurig>2004-09-10 12:34:40 (UTC)
committer schurig <schurig>2004-09-10 12:34:40 (UTC)
commit85928a3781d9a91b58ea414c0d7982459cc21920 (patch) (side-by-side diff)
tree10aeedf3a79fe2372c55bda730b6913b5562231b
parent9d0ccc1c5ca687bc017b2b515a9d3a47e98ce521 (diff)
downloadopie-85928a3781d9a91b58ea414c0d7982459cc21920.zip
opie-85928a3781d9a91b58ea414c0d7982459cc21920.tar.gz
opie-85928a3781d9a91b58ea414c0d7982459cc21920.tar.bz2
support for DEVFS
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--noncore/multimedia/opieplayer2/mediaplayer.cpp4
-rw-r--r--noncore/multimedia/opierec/device.cpp16
-rw-r--r--noncore/multimedia/opierec/qtrec.cpp7
3 files changed, 27 insertions, 0 deletions
diff --git a/noncore/multimedia/opieplayer2/mediaplayer.cpp b/noncore/multimedia/opieplayer2/mediaplayer.cpp
index 7b4bfd9..e6afbd8 100644
--- a/noncore/multimedia/opieplayer2/mediaplayer.cpp
+++ b/noncore/multimedia/opieplayer2/mediaplayer.cpp
@@ -1,403 +1,407 @@
#include "mediaplayer.h"
#include "audiowidget.h"
#include "videowidget.h"
#include "volumecontrol.h"
/* OPIE */
#include <opie2/odebug.h>
#include <qpe/qpeapplication.h>
#include <qpe/config.h>
/* QT */
#include <qfileinfo.h>
/* STD */
#include <linux/fb.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#define FBIOBLANK 0x4611
MediaPlayer::MediaPlayer( PlayListWidget &_playList, MediaPlayerState &_mediaPlayerState, QObject *parent, const char *name )
: QObject( parent, name ), volumeDirection( 0 ), mediaPlayerState( _mediaPlayerState ), playList( _playList ) {
m_audioUI = 0;
m_videoUI = 0;
m_xineControl = 0;
xine = new XINE::Lib( XINE::Lib::InitializeInThread );
fd=-1;fl=-1;
playList.setCaption( tr( "OpiePlayer: Initializating" ) );
qApp->processEvents();
// QPEApplication::grabKeyboard(); // EVIL
connect( qApp,SIGNAL( aboutToQuit()),SLOT( cleanUp()) );
connect( &mediaPlayerState, SIGNAL( playingToggled(bool) ), this, SLOT( setPlaying(bool) ) );
// What is pauseCheck good for? (Simon)
// connect( &mediaPlayerState, SIGNAL( pausedToggled(bool) ), this, SLOT( pauseCheck(bool) ) );
connect( &mediaPlayerState, SIGNAL( next() ), this, SLOT( next() ) );
connect( &mediaPlayerState, SIGNAL( prev() ), this, SLOT( prev() ) );
connect( &mediaPlayerState, SIGNAL( blankToggled(bool) ), this, SLOT ( blank(bool) ) );
volControl = new VolumeControl;
Config cfg( "OpiePlayer" );
cfg.setGroup("PlayList");
QString currentPlaylist = cfg.readEntry( "CurrentPlaylist", "default");
playList.setCaption( tr( "OpiePlayer: " ) + QFileInfo(currentPlaylist).baseName() );
m_skinLoader = new SkinLoader;
m_skinLoader->schedule( AudioWidget::guiInfo() );
m_skinLoader->schedule( VideoWidget::guiInfo() );
m_skinLoader->start();
}
MediaPlayer::~MediaPlayer() {
// this shold never happen, but one never knows...
if ( xine ) {
xine->ensureInitialized();
delete xine;
}
delete m_xineControl;
delete m_audioUI;
delete m_videoUI;
delete volControl;
}
void MediaPlayer::pauseCheck( bool b ) {
if ( b && !mediaPlayerState.isPlaying() ) {
mediaPlayerState.setPaused( FALSE );
}
}
void MediaPlayer::play() {
mediaPlayerState.setPlaying( FALSE );
mediaPlayerState.setPlaying( TRUE );
}
void MediaPlayer::setPlaying( bool play ) {
if ( !play ) {
return;
}
if ( mediaPlayerState.isPaused() ) {
mediaPlayerState.setPaused( FALSE );
return;
}
QString tickerText, time, fileName;
if ( playList.currentTab() != PlayListWidget::CurrentPlayList ) {
//if playing in file list.. play in a different way
// random and looping settings enabled causes problems here,
// since there is no selected file in the playlist, but a selected file in the file list,
// so we remember and shutoff
l = mediaPlayerState.isLooping();
if(l) {
mediaPlayerState.setLooping( false );
}
r = mediaPlayerState.isShuffled();
mediaPlayerState.setShuffled( false );
}
PlayListWidget::Entry playListEntry = playList.currentEntry();
fileName = playListEntry.name;
xineControl()->play( playListEntry.file );
long seconds = mediaPlayerState.length();
time.sprintf("%li:%02i", seconds/60, (int)seconds%60 );
if( fileName.left(4) == "http" ) {
fileName = QFileInfo( fileName ).baseName();
if ( xineControl()->getMetaInfo().isEmpty() ) {
tickerText = tr( " File: " ) + fileName;
} else {
tickerText = xineControl()->getMetaInfo();
}
} else {
if ( xineControl()->getMetaInfo().isEmpty() ) {
tickerText = tr( " File: " ) + fileName + tr( ", Length: " ) + time + " ";
} else {
tickerText = xineControl()->getMetaInfo() + " Length: " + time + " ";
}
}
audioUI()->setTickerText( tickerText );
}
void MediaPlayer::prev() {
if( playList.currentTab() == PlayListWidget::CurrentPlayList ) { //if using the playlist
if ( playList.prev() ) {
play();
} else if ( mediaPlayerState.isLooping() ) {
if ( playList.last() ) {
play();
}
} else {
mediaPlayerState.setList();
}
}
}
void MediaPlayer::next() {
if(playList.currentTab() == PlayListWidget::CurrentPlayList) { //if using the playlist
if ( playList.next() ) {
play();
} else if ( mediaPlayerState.isLooping() ) {
if ( playList.first() ) {
play();
}
} else {
mediaPlayerState.setList();
}
} else { //if playing from file list, let's just stop
odebug << "<<<<<<<<<<<<<<<<<stop for filelists" << oendl;
mediaPlayerState.setPlaying(false);
mediaPlayerState.setDisplayType( MediaPlayerState::MediaSelection );
if(l) mediaPlayerState.setLooping(l);
if(r) mediaPlayerState.setShuffled(r);
}
qApp->processEvents();
}
void MediaPlayer::startDecreasingVolume() {
volumeDirection = -1;
startTimer( 100 );
volControl->decVol(2);
}
void MediaPlayer::startIncreasingVolume() {
volumeDirection = +1;
startTimer( 100 );
volControl->incVol(2);
}
bool drawnOnScreenDisplay = FALSE;
unsigned int onScreenDisplayVolume = 0;
const int yoff = 110;
void MediaPlayer::stopChangingVolume() {
killTimers();
// Get rid of the on-screen display stuff
drawnOnScreenDisplay = FALSE;
onScreenDisplayVolume = 0;
int w=0;
int h=0;
if( !xineControl()->hasVideo() ) {
w = audioUI()->width();
h = audioUI()->height();
audioUI()->repaint( ( w - 200 ) / 2, h - yoff, 200 + 9, 70, FALSE );
} else {
w = videoUI()->width();
h = videoUI()->height();
videoUI()->repaint( ( w - 200 ) / 2, h - yoff, 200 + 9, 70, FALSE );
}
}
void MediaPlayer::timerEvent( QTimerEvent * ) {
if ( volumeDirection == +1 ) {
volControl->incVol( 2 );
} else if ( volumeDirection == -1 ) {
volControl->decVol( 2 );
}
// TODO FIXME
// huh??
unsigned int v= 0;
v = volControl->volume();
v = v / 10;
if ( drawnOnScreenDisplay && onScreenDisplayVolume == v ) {
return;
}
int w=0; int h=0;
if( !xineControl()->hasVideo() ) {
w = audioUI()->width();
h = audioUI()->height();
if ( drawnOnScreenDisplay ) {
if ( onScreenDisplayVolume > v ) {
audioUI()->repaint( ( w - 200 ) / 2 + v * 20 + 0, h - yoff + 40, ( onScreenDisplayVolume - v ) * 20 + 9, 30, FALSE );
}
}
drawnOnScreenDisplay = TRUE;
onScreenDisplayVolume = v;
QPainter p( audioUI() );
p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
QFont f;
f.setPixelSize( 20 );
f.setBold( TRUE );
p.setFont( f );
p.drawText( (w - 200) / 2, h - yoff + 20, tr("Volume") );
for ( unsigned int i = 0; i < 10; i++ ) {
if ( v > i ) {
p.drawRect( ( w - 200 ) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
} else {
p.drawRect( ( w - 200 ) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
}
}
} else {
w = videoUI()->width();
h = videoUI()->height();
if ( drawnOnScreenDisplay ) {
if ( onScreenDisplayVolume > v ) {
videoUI()->repaint( (w - 200) / 2 + v * 20 + 0, h - yoff + 40, ( onScreenDisplayVolume - v ) * 20 + 9, 30, FALSE );
}
}
drawnOnScreenDisplay = TRUE;
onScreenDisplayVolume = v;
QPainter p( videoUI() );
p.setPen( QColor( 0x10, 0xD0, 0x10 ) );
p.setBrush( QColor( 0x10, 0xD0, 0x10 ) );
QFont f;
f.setPixelSize( 20 );
f.setBold( TRUE );
p.setFont( f );
p.drawText( (w - 200) / 2, h - yoff + 20, tr( "Volume" ) );
for ( unsigned int i = 0; i < 10; i++ ) {
if ( v > i ) {
p.drawRect( (w - 200) / 2 + i * 20 + 0, h - yoff + 40, 9, 30 );
} else {
p.drawRect( (w - 200) / 2 + i * 20 + 3, h - yoff + 50, 3, 10 );
}
}
}
}
void MediaPlayer::blank( bool b ) {
+#ifdef QT_QWS_DEVFS
+ fd=open("/dev/fb/0",O_RDWR);
+#else
fd=open("/dev/fb0",O_RDWR);
+#endif
#ifdef QT_QWS_SL5XXX
fl= open( "/dev/fl", O_RDWR );
#endif
if (fd != -1) {
if ( b ) {
odebug << "do blanking" << oendl;
#ifdef QT_QWS_SL5XXX
ioctl( fd, FBIOBLANK, 1 );
if(fl !=-1) {
ioctl( fl, 2 );
::close(fl);
}
#else
ioctl( fd, FBIOBLANK, 3 );
#endif
isBlanked = TRUE;
} else {
odebug << "do unblanking" << oendl;
ioctl( fd, FBIOBLANK, 0);
#ifdef QT_QWS_SL5XXX
if(fl != -1) {
ioctl( fl, 1);
::close(fl);
}
#endif
isBlanked = FALSE;
}
close( fd );
} else {
odebug << "<< /dev/fb0 could not be opened >>" << oendl;
}
}
void MediaPlayer::keyReleaseEvent( QKeyEvent *e) {
switch ( e->key() ) {
////////////////////////////// Zaurus keys
case Key_Home:
break;
case Key_F9: //activity
break;
case Key_F10: //contacts
break;
case Key_F11: //menu
break;
case Key_F12: //home
odebug << "Blank here" << oendl;
// mediaPlayerState->toggleBlank();
break;
case Key_F13: //mail
odebug << "Blank here" << oendl;
// mediaPlayerState->toggleBlank();
break;
}
}
void MediaPlayer::cleanUp() {// this happens on closing
Config cfg( "OpiePlayer" );
mediaPlayerState.writeConfig( cfg );
playList.writeDefaultPlaylist( );
// QPEApplication::grabKeyboard();
// QPEApplication::ungrabKeyboard();
}
void MediaPlayer::recreateAudioAndVideoWidgets() const
{
delete m_skinLoader;
delete m_xineControl;
delete m_audioUI;
delete m_videoUI;
m_audioUI = new AudioWidget( playList, mediaPlayerState, 0, "audioUI" );
m_videoUI = new VideoWidget( playList, mediaPlayerState, 0, "videoUI" );
connect( m_audioUI, SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
connect( m_audioUI, SIGNAL( lessClicked() ), this, SLOT( startDecreasingVolume() ) );
connect( m_audioUI, SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
connect( m_audioUI, SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
connect( m_videoUI, SIGNAL( moreClicked() ), this, SLOT( startIncreasingVolume() ) );
connect( m_videoUI, SIGNAL( lessClicked() ), this, SLOT( startDecreasingVolume() ) );
connect( m_videoUI, SIGNAL( moreReleased() ), this, SLOT( stopChangingVolume() ) );
connect( m_videoUI, SIGNAL( lessReleased() ), this, SLOT( stopChangingVolume() ) );
if ( !xine )
xine = new XINE::Lib( XINE::Lib::InitializeImmediately );
m_xineControl = new XineControl( xine, m_videoUI->vidWidget(), mediaPlayerState );
xine = 0;
}
AudioWidget *MediaPlayer::audioUI() const
{
if ( !m_audioUI )
recreateAudioAndVideoWidgets();
return m_audioUI;
}
VideoWidget *MediaPlayer::videoUI() const
{
if ( !m_videoUI )
recreateAudioAndVideoWidgets();
return m_videoUI;
}
XineControl *MediaPlayer::xineControl() const
{
if ( !m_xineControl )
recreateAudioAndVideoWidgets();
return m_xineControl;
}
void MediaPlayer::reloadSkins()
{
audioUI()->loadSkin();
videoUI()->loadSkin();
}
diff --git a/noncore/multimedia/opierec/device.cpp b/noncore/multimedia/opierec/device.cpp
index 683f0a5..cb47b77 100644
--- a/noncore/multimedia/opierec/device.cpp
+++ b/noncore/multimedia/opierec/device.cpp
@@ -1,358 +1,374 @@
// device.cpp
#include "device.h"
#include <qpe/config.h>
#include <qpe/qcopenvelope_qws.h>
/* STD */
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/soundcard.h>
#include <unistd.h>
#include <sys/wait.h>
#include <unistd.h>
#include <errno.h>
//extern QtRec *qperec;
Device::Device( QObject * parent, const char * dsp, const char * mixr, bool record )
: QObject( parent)
{
dspstr = (char *)dsp;
mixstr = (char *)mixr;
devForm=-1;
devCh=-1;
devRate=-1;
if( !record){ //playing
qDebug( "setting up DSP for playing" );
flags = O_WRONLY;
} else { //recording
qDebug( "setting up DSP for recording" );
flags = O_RDWR;
// flags = O_RDONLY;
// selectMicInput();
}
}
bool Device::openDsp() {
if( openDevice( flags) == -1) {
perror("<<<<<<<<<<<<<<ioctl(\"Open device\")");
return false;
}
return true;
}
int Device::openDevice( int flags) {
/* pid_t pid;
int status;
int pipefd[2];
char message[20];
if (pipe(pipefd) == -1){
perror ("Error creating pipe");
exit(1);
}
switch (pid = fork()) {
case -1:
perror("The fork failed!");
break;
case 0: {
*/
qDebug( "Opening %s",dspstr);
if (( sd = ::open( dspstr, flags)) == -1) {
perror("open(\"/dev/dsp\")");
QString errorMsg="Could not open audio device\n /dev/dsp\n"
+(QString)strerror(errno);
qDebug( "XXXXXXXXXXXXXXXXXXXXXXX "+errorMsg );
return -1;
}
qDebug( "Opening mixer" );
int mixerHandle=0;
+#ifdef QT_QWS_DEVFS
+ if (( mixerHandle = open("/dev/sound/mixer",O_RDWR))<0) {
+#else
if (( mixerHandle = open("/dev/mixer",O_RDWR))<0) {
+#endif
perror("open(\"/dev/mixer\")");
QString errorMsg="Could not open audio device\n /dev/dsp\n"
+(QString)strerror(errno);
qDebug( "XXXXXXXXXXXXXXXXXXXXXX "+errorMsg );
}
if(ioctl(sd,SNDCTL_DSP_RESET,0)<0){
perror("ioctl RESET");
}
// sprintf(message, "%d", sd);
/* QFile f1("/pid");
f1.open(IO_WriteOnly );
f1.writeBlock(message, strlen(message));
f1.close();
*/
/* close(pipefd[0]);
write(pipefd[1], message, sizeof(message));
close(pipefd[1]);
// qDebug( "" + soundDevice->sd );
_exit(0);
}
default:
// pid greater than zero is parent getting the child's pid
printf("Child's pid is %d\n",pid);
QString s;
close(pipefd[1]);
read(pipefd[0], message, sizeof(message));
s = message;
close(pipefd[0]);
// while(wait(NULL)!=pid)
// ;
printf("child %ld terminated normally, return status is zero\n", (long) pid);
*/
// filePara.sd=(long) pid;
/* QFile f2("/pid");
f2.open(IO_ReadOnly);
QTextStream t(&f2);
// for(int f=0; f < t.atEnd() ;f++) {
s = t.readLine();
// }
*/
// bool ok;
// sd = s.toInt(&ok, 10);
// qDebug( "<<<<<<<<<<<<<>>>>>>>>>>>>"+s );
// f2.close();
// }
::close(mixerHandle );
// qDebug( "open device " + dspstr );
// qDebug( "success! " + sd );
return sd;
}
int Device::getOutVolume( ) {
unsigned int volume;
int mixerHandle = open( mixstr, O_RDWR );
if ( mixerHandle >= 0 ) {
if(ioctl( mixerHandle, MIXER_READ(SOUND_MIXER_VOLUME), &volume )==-1)
perror("<<<<<<<<<<<<<<ioctl(\"MIXER_READ\")");
::close( mixerHandle );
} else
perror("open(\"/dev/mixer\")");
printf("<<<<<<<<<<<<<<<<<<<<output volume %d\n",volume);
Config cfg("qpe");
cfg.setGroup("Volume");
return cfg.readNumEntry("VolumePercent");
}
int Device::getInVolume() {
unsigned int volume=0;
int mixerHandle = ::open( mixstr, O_RDWR );
if ( mixerHandle >= 0 ) {
if(ioctl( mixerHandle, MIXER_READ(SOUND_MIXER_MIC), &volume )==-1)
perror("<<<<<<<<<<<<<<<ioctl(\"MIXER_READ\")");
::close( mixerHandle );
} else
perror("open(\"/dev/mixer\")");
printf("<<<<<<<<<<<<<<input volume %d\n", volume );
Config cfg("qpe");
cfg.setGroup("Volume");
return cfg.readNumEntry("Mic");
}
void Device::changedOutVolume(int vol) {
int level = (vol << 8) + vol;
int fd = 0;
+#ifdef QT_QWS_DEVFS
+ if ((fd = open("/dev/sound/mixer", O_RDWR))>=0) {
+#else
if ((fd = open("/dev/mixer", O_RDWR))>=0) {
+#endif
if(ioctl(fd, MIXER_WRITE(SOUND_MIXER_VOLUME), &level) == -1)
perror("ioctl(\"MIXER_IN_WRITE\")");
Config cfg("qpe");
cfg.setGroup("Volume");
cfg.writeEntry("VolumePercent", QString::number( vol ));
QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;
qDebug("changing output vol %d" ,vol );
}
::close(fd);
}
void Device::changedInVolume(int vol ) {
int level = (vol << 8) + vol;
int fd = 0;
+#ifdef QT_QWS_DEVFS
+ if ((fd = open("/dev/sound/mixer", O_RDWR))>=0) {
+#else
if ((fd = open("/dev/mixer", O_RDWR))>=0) {
+#endif
if(ioctl(fd, MIXER_WRITE(SOUND_MIXER_MIC), &level) == -1)
perror("ioctl(\"MIXER_IN_WRITE\")");
Config cfg("qpe");
cfg.setGroup("Volume");
cfg.writeEntry("Mic", QString::number(vol ));
QCopEnvelope( "QPE/System", "micChange(bool)" ) << false;
qDebug("changing input volume %d",vol);
}
::close(fd);
}
bool Device::selectMicInput() {
int md=0;
int info=MIXER_WRITE(SOUND_MIXER_MIC);
+#ifdef QT_QWS_DEVFS
+ md = ::open( "/dev/sound/mixer", O_RDWR );
+#else
md = ::open( "/dev/mixer", O_RDWR );
+#endif
if ( md == -1)
perror("open(\"/dev/mixer\")");
else {
if( ioctl( md, SOUND_MIXER_WRITE_RECSRC, &info) == -1)
perror("ioctl(\"SOUND_MIXER_WRITE_RECSRC\")");
::close(md);
return false;
}
::close(md);
return true;
}
bool Device::closeDevice( bool) {
// if(b) {//close now
// if (ioctl( sd, SNDCTL_DSP_RESET, 0) == -1) {
// perror("ioctl(\"SNDCTL_DSP_RESET\")");
// }
// } else { //let play
// if (ioctl( sd, SNDCTL_DSP_SYNC, 0) == -1) {
// perror("ioctl(\"SNDCTL_DSP_SYNC\")");
// }
// }
::close( sd); //close sound device
// sdfd=0;
// sd=0;
// qDebug( "closed dsp" );
return true;
}
bool Device::setDeviceFormat( int form) {
qDebug( "set device res %d: %d ",form, sd );
if (ioctl( sd, SNDCTL_DSP_SETFMT, &form)==-1) { //set format
perror("ioctl(\"SNDCTL_DSP_SETFMT\")");
return false;
}
devRes=form;
return true;
}
bool Device::setDeviceChannels( int ch) {
qDebug( "set channels %d: %d",ch ,sd);
if (ioctl( sd, SNDCTL_DSP_CHANNELS, &ch)==-1) {
perror("ioctl(\"SNDCTL_DSP_CHANNELS\")");
return false;
}
devCh=ch;
return true;
}
bool Device::setDeviceRate( int rate) {
qDebug( "set rate %d: %d",rate,sd);
if (ioctl( sd, SNDCTL_DSP_SPEED, &rate) == -1) {
perror("ioctl(\"SNDCTL_DSP_SPEED\")");
return false;
}
devRate=rate;
return true;
}
int Device::getRes() {
return devRes;
}
int Device::getFormat() {
return devForm;
}
int Device::getRate() {
return devRate;
}
int Device::getChannels() {
return devCh;
}
int Device::getDeviceFormat() {
return 0;
}
int Device::getDeviceRate() {
int dRate=0;
if (ioctl( sd, SOUND_PCM_READ_RATE, &dRate) == -1) {
perror("ioctl(\"SNDCTL_PCM_READ_RATE\")");
}
return dRate;
}
int Device::getDeviceBits() {
int dBits=0;
#ifndef QT_QWS_EBX // zaurus doesnt have this
if (ioctl( sd, SOUND_PCM_READ_BITS, &dBits) == -1) {
perror("ioctl(\"SNDCTL_PCM_READ_BITS\")");
}
#endif
return dBits;
}
int Device::getDeviceChannels() {
int dCh=0;
if (ioctl( sd, SOUND_PCM_READ_CHANNELS, &dCh) == -1) {
perror("ioctl(\"SNDCTL_PCM_READ_CHANNELS\")");
}
return dCh;
}
int Device::getDeviceFragSize() {
int frag_size;
if (ioctl( sd, SNDCTL_DSP_GETBLKSIZE, &frag_size) == -1) {
qDebug( "no fragsize" );
} else {
qDebug( "driver says frag size is %d",frag_size);
}
return frag_size;
}
bool Device::setFragSize(int frag) {
if (ioctl(sd, SNDCTL_DSP_SETFRAGMENT, &frag)) {
perror("ioctl(\"SNDCTL_DSP_SETFRAGMENT\")");
return false;
}
return true;
}
bool Device::reset() {
closeDevice(true);
openDsp();
if (ioctl( sd, SNDCTL_DSP_RESET, 0) == -1) {
perror("ioctl(\"SNDCTL_DSP_RESET\")");
return false;
}
return true;
}
int Device::devRead(int soundDescriptor, short *buf, int size) {
Q_UNUSED(soundDescriptor);
int number = 0;
number = ::read( sd /*soundDescriptor*/, (char *)buf, size);
return number;
}
int Device::devWrite(int soundDescriptor, short * buf, int size) {
Q_UNUSED(soundDescriptor);
int bytesWritten = 0;
bytesWritten = ::write( sd /*soundDescriptor*/, buf, size);
return bytesWritten;
}
diff --git a/noncore/multimedia/opierec/qtrec.cpp b/noncore/multimedia/opierec/qtrec.cpp
index 1141faa..c237726 100644
--- a/noncore/multimedia/opierec/qtrec.cpp
+++ b/noncore/multimedia/opierec/qtrec.cpp
@@ -1,1621 +1,1628 @@
/****************************************************************************
// 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 DSPSTRMIXEROUT "/dev/mixer"
#ifdef SHARP
#define DSPSTRIN "/dev/dsp1"
#define DSPSTRMIXERIN "/dev/mixer1"
#else
#define DSPSTRIN "/dev/dsp"
#define DSPSTRMIXERIN "/dev/mixer"
#endif
#else
+#ifdef QT_QWS_DEVFS
+#define DSPSTROUT "/dev/sound/dsp"
+#define DSPSTRIN "/dev/sound/dsp"
+#define DSPSTRMIXERIN "/dev/sound/mixer"
+#define DSPSTRMIXEROUT "/dev/sound/mixer"
+#else
#define DSPSTROUT "/dev/dsp"
#define DSPSTRIN "/dev/dsp"
#define DSPSTRMIXERIN "/dev/mixer"
#define DSPSTRMIXEROUT "/dev/mixer"
+#endif
#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;
QMessageBox::message("Note","<p>There was a problem writing to the file</p>");
perror("File writing error ");
return;
}
total += bytesWritten;
filePara.numberSamples = total;
// printf("%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()
#ifdef THREADED
void playIt()
#else
void QtRec::playIt()
#endif
{
int bytesWritten = 0;
int number = 0;
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];
// }
bytesWritten = write ( filePara.sd, sbuf, number * 4);
waveform->newSamples( (const short *)sbuf, number *4);
// if(filePara.channels==1)
// total += bytesWritten/2; //mono
// else
total += bytesWritten;
filePara.numberSamples = total/4;
filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / 2;
timeSlider->setValue( total/4);
// 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);
// fflush(stdout);
qApp->processEvents();
if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
// if( total >= filePara.numberSamples ){//|| secCount > filePara.numberOfRecordedSeconds ) {
stopped = true;
break;
}
}
} else {
// <<<<<<<<<<<<<<<<<<<<<<<<<<< WAVE_FORMAT_PCM >>>>>>>>>>>>>>>>>>>>>>
short inbuffer[ BUFSIZE ], outbuffer[ BUFSIZE ];
memset( inbuffer, 0, BUFSIZE);
memset( outbuffer, 0, BUFSIZE);
for(;;) { // play loop
if ( stopped) {
break;
return;
}
// 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);
waveform->newSamples( inbuffer, number);
//-------------->>>> out to device
// total+=bytesWritten;
// if(filePara.channels==1)
// total += bytesWritten/2; //mono
// else
total += bytesWritten;
timeSlider->setValue( total);
filePara.numberSamples = total;
filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate / (float)2;
// timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
// timeLabel->setText( timeString + tr(" seconds"));
qApp->processEvents();
if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
owarn << "Jane! Stop this crazy thing!" << oendl;
stopped = true;
// playing = false;
break;
}
}
// 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
return;
}
number = ::read( filePara.fd, unsigned_inbuffer, BUFSIZE);
//data = (val >> 8) ^ 0x80;
// unsigned_outbuffer = (unsigned_inbuffer >> 8) ^ 0x80;
bytesWritten = write ( filePara.sd, unsigned_inbuffer, number);
waveform->newSamples( (const short *)unsigned_inbuffer, bytesWritten );
total += bytesWritten;
timeSlider->setValue( total);
filePara.numberSamples = total;
filePara.numberOfRecordedSeconds = (float)total / (float)filePara.sampleRate;
// timeString.sprintf("%.2f",filePara.numberOfRecordedSeconds);
// timeLabel->setText( timeString + tr(" seconds"));
qApp->processEvents();
if( /*total >= filePara.numberSamples || */ bytesWritten == 0) {
// if( total >= filePara.numberSamples ) {
stopped = true;
break;
}
// printf("Writing number %d, bytes %d, total %d, numberSamples %d\r",number, bytesWritten , total, filePara.numberSamples);
// fflush(stdout);
}
}
}
QtRec::QtRec( QWidget* parent, const char* name, WFlags fl )
: QWidget( parent, name, fl )
{
if ( !name )
setName( "OpieRec" );
init();
initConfig();
initConnections();
renameBox = 0;
// open sound device to get volumes
Config hwcfg("OpieRec");
hwcfg.setGroup("Hardware");
soundDevice = new Device( this,
hwcfg.readEntry( "Audio",DSPSTROUT),
hwcfg.readEntry( "Mixer",DSPSTRMIXEROUT), false);
// soundDevice = new Device( this, hwcfg.readEntry( "Audio","hw:0"), hwcfg.readEntry( "Mixer","hw:0"), 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() {
// if( soundDevice) delete soundDevice;
}
void QtRec::cleanUp() {
if( !stopped) {
stopped = true;
endRecording();
}
ListView1->clear();
if( autoMute)
doMute(false);
// if( wavFile) delete wavFile;
// if(soundDevice) delete soundDevice;
}
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( "OpieRecord " ) + 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, 8);
// 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" );
layout1->addMultiCellWidget( timeSlider, 1, 1, 0, 3);
// timeLabel = new QLabel( tab, "TimeLabel" );
// layout1->addMultiCellWidget( timeLabel, 0, 0, 0, 3);
// playLabel2 = new QLabel(tab, "PlayLabel2" );
// playLabel2->setText(tr("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(tr("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() ),
this, SLOT( rewindTimerTimeout() ) );
forwardTimer = new QTimer( this );
connect( forwardTimer, SIGNAL( timeout() ),
this, SLOT( forwardTimerTimeout() ) );
deleteSoundButton = new QPushButton( tab, "deleteSoundButton" );
layout1->addMultiCellWidget( deleteSoundButton, 1, 1, 8, 8);
deleteSoundButton->setText( tr( "Del" ) );
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, -1);
// ListView1->addColumn( tr("Location") );
// ListView1->setColumnWidth( 2, -1);
// ListView1->addColumn( tr("Date") );
// ListView1->setColumnWidth( 3, -1);
ListView1->setColumnWidthMode(0, QListView::Maximum);
// ListView1->setColumnWidthMode(1, QListView::Maximum);
// 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
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" );
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"), tab_3 );
glayout3->addMultiCellWidget( compressionCheckBox, 2, 2, 0, 3);
glayout3->addMultiCellWidget( autoMuteCheckBox, 3, 3, 0, 0);
glayout3->addMultiCellWidget( stereoCheckBox, 3, 3, 1, 1);
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 ( tr("mute"), tab_5 );
Layout15->addWidget( outMuteCheckBox );
inMuteCheckBox = new QCheckBox ( tr("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" ) );
waveform = new Waveform( this, "waveform" );
// waveform->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)5, (QSizePolicy::SizeType)3, waveform->sizePolicy().hasHeightForWidth() ) );
waveform->setMinimumSize( QSize( 0, 50 ) );
layout->addMultiCellWidget( waveform, 8, 8, 0, 8);
waveform->setBackgroundColor ( black );
}
void QtRec::initIconView() {
ListView1->clear();
Config cfg("OpieRec");
cfg.setGroup("Sounds");
QString temp;
QPixmap image0( ( const char** ) image0_data );
int nFiles = cfg.readNumEntry("NumberofFiles",0);
// odebug << "init number of files " << nFiles << "" << oendl;
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( 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( stereoCheckBox, SIGNAL(toggled(bool)),
this, SLOT( changeStereoCheck(bool)) );
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("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( 1);
else if(i == 24)
bitRateComboBox->setCurrentItem( 2);
else if(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
slotAutoMute(false);
Config cofg( "qpe");
cofg.setGroup( "Volume");
outMuteCheckBox->setChecked( cofg.readBoolEntry( "Mute",0));
inMuteCheckBox->setChecked( cofg.readBoolEntry( "MicMute",0));
}
void QtRec::stop() {
owarn << "STOP" << oendl;
setRecordButton(false);
if( !recording)
endPlaying();
else
endRecording();
timeSlider->setValue(0);
}
void QtRec::doPlayBtn() {
if(!stopped) {
// playLabel2->setText(tr("Play"));
stop();
} else {
if(ListView1->currentItem() == 0) return;
// playLabel2->setText(tr("Stop"));
currentFile = ListView1->currentItem()->text(0);
start();
}
}
void QtRec::start() { //play
if( stopped) {
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
QString timeString;
timeString.sprintf("%.0f", 0.0);
// timeLabel->setText( timeString+ " seconds");
if(!stopped) {
monitoring = true;
return false;
} else {
secCount = 1;
// playLabel2->setText(tr("Stop"));
monitoring = false;
setRecordButton( true);
if( setupAudio( true))
if(setUpFile()) {
int fileSize = 0;
Config cfg("OpieRec");
cfg.setGroup("Settings");
// odebug << "<<<<<<<Device bits " << soundDevice->getDeviceBits()
// << ", device rate " << soundDevice->getDeviceRate()
// << ", device channels " << soundDevice->getDeviceChannels() << oendl;
//filePara.sampleRate = cfg.readNumEntry("samplerate", 22050);
// odebug << "sample rate is " << filePara.sampleRate << "" << oendl;
filePara.SecondsToRecord = getCurrentSizeLimit();
// odebug << "size limit " << filePara.SecondsToRecord << " sec" << oendl;
int diskSize = checkDiskSpace( (const QString &) wavFile->trackName());
if( filePara.SecondsToRecord == 0) {
fileSize = diskSize;
} else if( filePara.format == WAVE_FORMAT_PCM) {
// odebug << "WAVE_FORMAT_PCM" << oendl;
fileSize = (filePara.SecondsToRecord ) * filePara.channels
* filePara.sampleRate * ( filePara.resolution / 8) + 1000;
} else {
// odebug << "WAVE_FORMAT_DVI_ADPCM" << oendl;
fileSize = ((filePara.SecondsToRecord) * filePara.channels
* filePara.sampleRate * ( filePara.resolution / 8) ) / 4 + 250;
}
filePara.samplesToRecord = fileSize;
odebug << "filesize should be " << filePara.samplesToRecord
<< ", bits " << filePara.resolution << ", rate " << filePara.sampleRate;
if( paused) {
paused = false;
}
// else {
odebug << "Setting timeslider " << filePara.samplesToRecord << "" << oendl;
// 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();
odebug << "Start recording" << oendl;
stopped = false;
#ifdef THREADED
odebug << "Start recording thread" << oendl;
pthread_t thread1;
pthread_create( &thread1, NULL, (void * (*)(void *))quickRec, NULL/* &*/);
#endif
toBeginningButton->setEnabled( false);
toEndButton->setEnabled( false);
startTimer(1000);
#ifndef THREADED
quickRec();
#endif
}
} //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();
update();
}
}
void QtRec::getOutVol( ) {
filePara.outVol = soundDevice->getOutVolume();
// odebug << "out vol " << filePara.outVol << "" << oendl;
OutputSlider->setValue( -filePara.outVol);
}
void QtRec::getInVol() {
filePara.inVol = soundDevice->getInVolume();
// odebug << "in vol " << filePara.inVol << "" << oendl;
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;
QString dspString, mixerString;
filePara.resolution = bitRateComboBox->currentText().toInt( &ok,10); //16
if( !b) {
// we want to play
#ifdef PDAUDIO //ALSA
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
// 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;
Config hwcfg("OpieRec");
hwcfg.setGroup("Hardware");
dspString = hwcfg.readEntry( "Audio", DSPSTROUT);
mixerString = hwcfg.readEntry( "Mixer", DSPSTRMIXEROUT);
recording = false;
} else { // we want to record
#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;
// odebug << "WAVE_FORMAT_PCM" << oendl;
} else {
filePara.format = WAVE_FORMAT_DVI_ADPCM;
sampleformat = AFMT_S16_LE;
// odebug << "WAVE_FORMAT_DVI_ADPCM" << oendl;
}
#endif
stereo = filePara.channels;
// filePara.sampleRate = sampleRateComboBox->currentText().toInt( &ok,10);//44100;
flags= O_RDWR;
// flags= O_RDONLY;
Config hwcfg("OpieRec");
hwcfg.setGroup("Hardware");
dspString = hwcfg.readEntry( "Audio", DSPSTRIN);
mixerString = hwcfg.readEntry( "Mixer", DSPSTRMIXERIN);
recording = true;
}
// if(soundDevice) delete soundDevice;
odebug << "<<<<<<<<<<<<<<<<<<<open dsp " << filePara.sampleRate << " " << filePara.channels << " " << sampleformat << "" << oendl;
owarn << "change waveform settings" << oendl;
waveform->changeSettings( filePara.sampleRate, filePara.channels );
soundDevice = new Device( this, dspString, mixerString, b);
// soundDevice->openDsp();
soundDevice->reset();
odebug << "device has been made " << soundDevice->sd << "" << oendl;
////////////////// <<<<<<<<<<<<>>>>>>>>>>>>
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( "OpieRecord " )+ QString::number(VERSION) );
return false;
}
if(autoMute)
doMute(false);
return true;
}
bool QtRec::setUpFile() { //setup file for recording
// odebug << "Setting up wavfile" << oendl;
// 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() {
if( !paused) {
total = 0;
filePara.numberOfRecordedSeconds = 0;
} else {
paused = false;
secCount = (int)filePara.numberOfRecordedSeconds;
}
playing = true;
stopped = false;
recording = false;
QString num;
odebug << "Play number of samples " << filePara.numberSamples << "" << oendl;
// timeSlider->setRange( 0, filePara.numberSamples);
timeString.sprintf("%f", 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);
#ifdef THREADED
pthread_t thread2;
pthread_create( &thread2, NULL, (void * (*)(void *))playIt, NULL/* &*/);
#endif
toBeginningButton->setEnabled( false);
toEndButton->setEnabled( false);
#ifndef THREADED
playIt();
#endif
return true;
}
void QtRec::changebitrateCombo(int i) {
Config cfg("OpieRec");
cfg.setGroup("Settings");
int bits = 0;
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;
odebug << "Change sample rate " << rate << "" << oendl;
cfg.write();
}
void QtRec::changeDirCombo(int index) {
Config cfg("OpieRec");
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);
odebug << "new rec dir "+recDir << oendl;
}
}
cfg.write();
}
void QtRec::changeSizeLimitCombo(int) {
Config cfg("OpieRec");
cfg.setGroup("Settings");
cfg.writeEntry("sizeLimit", getCurrentSizeLimit() );
cfg.write();
}
void QtRec::newSound() {
if( !rec()) {
endRecording();
deleteSound();
}
}
void QtRec::itClick(QListViewItem *item) {
currentFile = item->text(0);
setCaption("OpieRecord "+currentFile);
}
void QtRec::deleteSound() {
Config cfg("OpieRec");
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);
QString fileName;
fileName = cfg.readEntry( file, "");
QFile f( 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++) {
if( cfg.readEntry( QString::number(i),"").find( file,0,true) != -1) {
found = true;
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.writeEntry( "NumberofFiles", nFiles-1);
cfg.write();
ListView1->takeItem( ListView1->currentItem() );
delete ListView1->currentItem();
ListView1->clear();
ListView1->setSelected( ListView1->firstChild(), true);
initIconView();
update();
}
#ifndef DEV_VERSION
};
#endif
setCaption( tr( "OpieRecord " ) + QString::number(VERSION) );
}
void QtRec::keyPressEvent( QKeyEvent *e) {
switch ( e->key() ) {
// 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: {
odebug << "rewinding" << oendl;
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();
odebug << "Up" << oendl;
break;
case Key_Down:
// start();
// odebug << "Down" << oendl;
// newSound();
break;
case Key_Left:
odebug << "Left" << oendl;
rewindReleased();
break;
case Key_Right:
odebug << "Right" << oendl;
FastforwardReleased();
break;
}
}
void QtRec::endRecording() {
monitoring = false;
recording = false;
stopped = true;
waveform->reset();
setRecordButton( false);
toBeginningButton->setEnabled( true);
toEndButton->setEnabled( true);
killTimers();
if(autoMute)
doMute( true);
soundDevice->closeDevice( true);
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);
odebug << "moving tmp file to "+currentFileName << oendl;
system( cmd.latin1());
}
odebug << "Just moved " + wavFile->currentFileName << oendl;
Config cfg("OpieRec");
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 );
odebug << "writing config numberOfRecordedSeconds "+time << oendl;
cfg.write();
odebug << "finished recording" << oendl;
// timeLabel->setText("");
}
// if(soundDevice) delete soundDevice;
timeSlider->setValue(0);
initIconView();
selectItemByName( currentFile);
}
void QtRec::endPlaying() {
monitoring = false;
recording = false;
playing = false;
stopped = true;
waveform->reset();
// errorStop();
odebug << "end playing" << oendl;
setRecordButton( false);
toBeginningButton->setEnabled( true);
toEndButton->setEnabled( true);
if(autoMute)
doMute( true);
soundDevice->closeDevice( false);
soundDevice->sd = -1;
// if(soundDevice) delete soundDevice;
odebug << "file and sound device closed" << oendl;
// timeLabel->setText("");
total = 0;
filePara.numberSamples = 0;
filePara.sd = -1;
// wavFile->closeFile();
filePara.fd = 0;
// if(wavFile) delete wavFile; //this crashes
odebug << "track closed" << oendl;
killTimers();
owarn << "reset slider" << oendl;
timeSlider->setValue(0);
// if(soundDevice) delete soundDevice;
}
bool QtRec::openPlayFile() {
qApp->processEvents();
if( currentFile.isEmpty()) {
QMessageBox::message(tr("Opierec"),tr("Please select file to play"));
endPlaying();
return false;
}
QString currentFileName;
Config cfg("OpieRec");
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, "" );
odebug << "opening for play: " + currentFileName << oendl;
}
}
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( "OpieRecord " ) + 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();
filePara.sampleRate = wavFile->getSampleRate();
filePara.resolution = wavFile->getResolution();
filePara.channels = wavFile->getChannels();
timeSlider->setPageStep(1);
monitoring = true;
odebug << "file " << filePara.fd << ", samples " << filePara.numberSamples << " " << filePara.sampleRate << "" << oendl;
int sec = (int) (( filePara.numberSamples / filePara.sampleRate) / filePara.channels) / ( filePara.channels*( filePara.resolution/8));
owarn << "seconds " << sec << "" << oendl;
timeSlider->setRange(0, filePara.numberSamples );
}
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( "OpieRecord " + currentFile);