FullDuplex.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/
#ifndef FULLDUPLEX_H
#define CAPTURE_H

#include <ALSA/ALSA.H>

namespace ALSA {
        template<typename FRAME_TYPE>
        class FullDuplex : public Capture, public Playback {
                int writeReadProcess(){
                        int ret=Playback::writeBuf(outputAudio);
                        if (ret==0)
                                ret=Capture::readBuf(inputAudio);
                        if (ret==0)
                                ret=process();
                        return ret;
                }

                virtual int process()=0;
protected:
        Eigen::Array<FRAME_TYPE, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> inputAudio;
        Eigen::Array<FRAME_TYPE, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> outputAudio;

        public:
                FullDuplex(const char *devName) : Capture(devName), Playback(devName) {}

                FullDuplex(const char *playDevName, const char *captureDevName) : Capture(captureDevName), Playback(playDevName) {}

                virtual ~FullDuplex(void){}

                int link(){
                        return snd_pcm_link(Playback::getPCM(), Capture::getPCM());
                }

                int unLink(){
                        return snd_pcm_unlink(Capture::getPCM());
                }

                virtual int go(){
                        int ret=process(), ret2; // call the user's process method to initialise mamber variables.
                        if (ret<0)
                                return ALSADebug().evaluateError(ALSA_YOUR_PROCESS_FN_ERROR);

                        if (inputAudio.rows()!=outputAudio.rows()) // check for frames mismatch
                                return ALSADebug().evaluateError(ALSA_FRAME_MISMATCH_ERROR, "Your process method didn't initialise the inputAudio and outputAudio member variables with the same number of frames.");
                        if (inputAudio.cols()==0 || outputAudio.cols()==0) // check for no channels
                                return ALSADebug().evaluateError(ALSA_NO_CHANNELS_ERROR, "Your process method didn't initialise the inputAudio and outputAudio member variables with any channels.");

                        if (!Playback::prepared()){
                                // set the playback and capture channels and period sizes accordingly and set the parameters
                                if ((ret=Playback::setChannels(outputAudio.cols()))<0)
                                        return ALSADebug().evaluateError(ret);
                                if ((ret=Capture::setChannels(inputAudio.cols()))<0)
                                        return ALSADebug().evaluateError(ret);
                                if ((ret=Playback::setBufSize(outputAudio.rows()))<0)
                                        return ALSADebug().evaluateError(ret);
                                if ((ret=Capture::setBufSize(inputAudio.rows()))<0)
                                        return ALSADebug().evaluateError(ret);

                                if (sizeof(FRAME_TYPE)!=Playback::getFormatPhysicalWidth()/8){
                                        printf("sizeof(FRAME_TYPE) = %d, Playback::getFormatPhysicalWidth()/8 = %ld\n", sizeof(FRAME_TYPE), Playback::getFormatPhysicalWidth()/8);
                                        return ALSADebug().evaluateError(ALSA_FORMAT_MISMATCH_ERROR, " When comparing the FullDuplex sample type template word against the ALSA format word. ");
                                }

                                Playback::setParams();
                                Capture::setParams();
                        }
                        // Capture::enableLog();
                        // std::cout<<"status"<<std::endl;
                        // Capture::dumpStatus();
                        // std::cout<<"PCM"<<std::endl;
                        // Capture::dumpPCM();
                        // std::cout<<"setup"<<std::endl;
                        // Capture::dumpSetup();
                        // std::cout<<"\n\nHW setup"<<std::endl;
                        // Capture::dumpHWSetup();
                        // std::cout<<"\nHW params"<<std::endl;
                        // Capture::dumpHWParams();
                        // std::cout<<"\n\nSW setup"<<std::endl;
                        // Capture::dumpSWSetup();
                        // std::cout<<"\nSW params"<<std::endl;
                        // Capture::dumpSWParams();

                        if ((ret=link())<0)
                                return ALSADebug().evaluateError(ret);

                        while ((ret=writeReadProcess())==0)
                                ;
                        if (Playback::running())
                                Playback::drop(); // stop the pcm
                        if ((ret2=unLink())<0)
                                if (ret>=0)
                                        return ALSADebug().evaluateError(ret2);
                                else
                                        ALSADebug().evaluateError(ret2);
                        return ret;
                }

                int resetParams() {
                        int ret=0;
                        if (ret=Playback::resetParams()<0)
                                return ret;
                        return Capture::resetParams();
                }

                int setFormat(snd_pcm_format_t format) {
                        int ret=0;
                        if (ret=Playback::setFormat(format)<0)
                                return ret;
                        return Capture::setFormat(format);
                }

                int setAccess(snd_pcm_access_t access) {
                        int ret=0;
                        if (ret=Playback::setAccess(access)<0)
                                return ret;
                        return Capture::setAccess(access);
                };

                int setSampleRate(unsigned int rrate, int dir=0) {
                        int ret=0;
                        if (ret=Playback::setSampleRate(rrate, dir)<0)
                                return ret;
                        return Capture::setSampleRate(rrate, dir);
                }

                int setBufSize(snd_pcm_uframes_t bufSize) {
                        int ret=0;
                        if (ret=Playback::setBufSize(bufSize)<0)
                                return ret;
                        return Capture::setBufSize(bufSize);
                }

                int setChannels(unsigned int cnt) {
                        int ret=0;
                        if (ret=Playback::setChannels(cnt)<0)
                                return ret;
                        return Capture::setChannels(cnt);
                }
        };
}
#endif //FULLDUPLEX_H