device.cpp

Go to the documentation of this file.

// device.cpp

#include "device.h"

#include <qpe/config.h>
#include <qpe/qcopenvelope_qws.h>

#include <opie2/odebug.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;
#if defined(QT_QWS_SL5XXX)


#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

Device::Device( QObject * parent, bool record )
        : QObject( parent)
{
//    dspstr = dsp;
    devForm = -1;
    devCh = -1;
    devRate = -1;

    if( !record){ //playing
        owarn << "New Sound device DSP for playing" << oendl;
        flags = O_RDWR;
//        flags = O_WRONLY;
    } else { //recording
        owarn << "New Sound device DSP for recording" << oendl;
        flags = O_RDWR;
//        flags = O_RDONLY;
                                selectMicInput();
    }
}

bool Device::openDsp() {
                qWarning("Device::openDsp()");
    if( openDevice( flags) == -1) {
        perror("<<<<<<<<<<<<<<ioctl(\"Open device\")");
        return false;
    }
    return true;
}

int Device::openDevice( int flags) {
                owarn << "Opening sound device:"<< DSPSTROUT << oendl;

                if (( sd = ::open( DSPSTROUT, O_RDWR)) == -1) {
                                perror("open(\"/dev/dsp\")\n");
                                QString errorMsg="Could not open audio device\n /dev/dsp\n"
                                                +(QString)strerror(errno);
                                qDebug( "XXXXXXXXXXXXXXXXXXXXXXX  "+errorMsg );
                                return -1;
                }

                if(ioctl(sd,SNDCTL_DSP_RESET,0)<0){
                                perror("ioctl RESET");
                }
                qWarning("opened!");
    return sd;
}

int Device::getInVolume() {
    unsigned int volume = 0;
    Config cfg("qpe");
    cfg.setGroup("Volume");

    return cfg.readNumEntry("Mic");
}

int Device::getOutVolume( ) {
    unsigned int volume;
    Config cfg("qpe");
    cfg.setGroup("Volume");

    return cfg.readNumEntry("VolumePercent");
}


void Device::changedInVolume(int vol ) {
                Config cfg("qpe");
                cfg.setGroup("Volume");
                cfg.writeEntry("Mic", QString::number(vol ));
                QCopEnvelope( "QPE/System", "micChange(bool)" ) << false;
}

void Device::changedOutVolume(int vol) {
                Config cfg("qpe");
                cfg.setGroup("Volume");
                cfg.writeEntry("VolumePercent", QString::number( vol ));

                QCopEnvelope( "QPE/System", "volumeChange(bool)" ) << false;

                owarn << "changing output vol " << vol << oendl;
}

bool Device::selectMicInput() {

                int md = 0;
                int info = SOUND_MASK_MIC;//MIXER_WRITE(SOUND_MIXER_MIC);
                owarn << "sectMicInput" << oendl;
                md = ::open( DSPSTRMIXEROUT, O_RDWR );

                if ( md <= 0) {
                                QString err;
                                err.sprintf("open %s", DSPSTRMIXEROUT);
                                perror(err.latin1());
                } 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(sd)
    ::close( sd); //close sound device
    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;
     if (ioctl( sd, SOUND_PCM_READ_BITS, &dBits) == -1) {
         perror("ioctl(\"SNDCTL_PCM_READ_BITS\")");
     }
    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;
}

---