mipossinputoutput.h

Go to the documentation of this file.

/*
    
  This file is a part of EMIPLIB, the EDM Media over IP Library.
  
  Copyright (C) 2006-2011  Hasselt University - Expertise Centre for
                      Digital Media (EDM) (http://www.edm.uhasselt.be)

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

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef MIPOSSINPUTOUTPUT_H

#define MIPOSSINPUTOUTPUT_H

#include "mipconfig.h"

#ifdef MIPCONFIG_SUPPORT_OSS

#include "mipcomponent.h"
#include "miptime.h"
#include "mipsignalwaiter.h"
#include <jthread/jthread.h>
#include <string>

class MIPRaw16bitAudioMessage;

class EMIPLIB_IMPORTEXPORT MIPOSSInputOutputParams
{
public:
        MIPOSSInputOutputParams() : m_bufferTime(10.0), m_ossBufferTime(0.007), m_devName("/dev/dsp")
                                                                                        { m_exactRate = true; m_ossFragments = 6; }
        ~MIPOSSInputOutputParams()                                                      { }

        void setUseExactRate(bool f)                                                    { m_exactRate = f; }

        void setBufferTime(MIPTime t)                                                   { m_bufferTime = t; }

        void setDeviceName(const std::string &name)                                     { m_devName = name; }

        void setOSSBufferSize(MIPTime t)                                                { m_ossBufferTime = t; }

        void setOSSFragments(uint16_t n)                                                { m_ossFragments = n; }

        bool useExactRate() const                                                       { return m_exactRate; }

        MIPTime getBufferTime() const                                                   { return m_bufferTime; }

        std::string getDeviceName() const                                               { return m_devName; }

        MIPTime getOSSBufferSize() const                                                { return m_ossBufferTime; }

        uint16_t getOSSFragments() const                                                { return m_ossFragments; }
private:
        bool m_exactRate;
        uint16_t m_ossFragments;
        MIPTime m_bufferTime, m_ossBufferTime;
        std::string m_devName;
};

class EMIPLIB_IMPORTEXPORT MIPOSSInputOutput : public MIPComponent
{
public:
        enum AccessMode { ReadOnly, WriteOnly, ReadWrite };
        
        MIPOSSInputOutput();
        ~MIPOSSInputOutput();
        
        bool open(int sampRate, int channels, MIPTime interval, AccessMode accessMode = WriteOnly, 
                  const MIPOSSInputOutputParams *pParams = 0);
        
        int getSamplingRate() const                                                     { return m_sampRate; }

        uint32_t getRawAudioSubtype() const                                             { return m_audioSubtype; }
        
        bool close();
        
        bool push(const MIPComponentChain &chain, int64_t iteration, MIPMessage *pMsg);
        bool pull(const MIPComponentChain &chain, int64_t iteration, MIPMessage **pMsg);
private:
        class IOThread : public jthread::JThread
        {
        public:
                IOThread(MIPOSSInputOutput &ossIO);
                ~IOThread();
                void stop();
        protected:
                MIPOSSInputOutput &m_ossIO;
                jthread::JMutex m_stopMutex;
                bool m_stopLoop;
        };

        class InputThread : public IOThread
        {
        public:
                InputThread(MIPOSSInputOutput &ossIO) : IOThread(ossIO)         { }
                ~InputThread()                                                  { stop(); }
                void *Thread();
        };
        
        class OutputThread : public IOThread
        {
        public:
                OutputThread(MIPOSSInputOutput &ossIO) : IOThread(ossIO)        { }
                ~OutputThread()                                                 { stop(); }
                void *Thread();
        };

        bool inputThreadStep();
        bool outputThreadStep();

        InputThread *m_pInputThread;
        OutputThread *m_pOutputThread;

        friend class InputThread;
        friend class OutputThread;

        int m_device;
        int m_sampRate;
        int m_channels;
        AccessMode m_accessMode;
        uint32_t m_audioSubtype;
        bool m_isSigned;

        uint16_t *m_pInputBuffer;
        uint16_t *m_pLastInputCopy;
        uint16_t *m_pMsgBuffer;
        MIPRaw16bitAudioMessage *m_pMsg;
        bool m_gotLastInput;
        bool m_gotMsg;
        MIPSignalWaiter m_sigWait;
        MIPTime m_sampleInstant;

        uint16_t *m_pOutputBuffer;
        size_t m_bufferLength, m_blockLength, m_blockFrames;
        size_t m_curOutputPos;
        size_t m_nextOutputPos;
        MIPTime m_blockTime,m_outputDistTime;

        jthread::JMutex m_inputFrameMutex, m_outputFrameMutex;
};

#endif // MIPCONFIG_SUPPORT_OSS

#endif // MIPOSSINPUTOUTPUT_H