drivers/audio/AudioOutputDeviceAsio.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2007 Christian Schoenebeck                       *
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   This program 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 should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#ifndef _LS_AUDIOOUTPUTDEVICEASIO_H_
#define _LS_AUDIOOUTPUTDEVICEASIO_H_

#include <string.h>

#include <asiosys.h>
#include <asio.h>
#include <asiodrivers.h>
#include <math.h>
#include "iasiothiscallresolver.h"

#include "../../common/global_private.h"
#include "AudioOutputDevice.h"
#include "AudioChannel.h"
#include "../DeviceParameter.h"

namespace LinuxSampler { //

    /** Asio audio output driver
      *
      * Implements audio output to the Advanced Linux Sound Architecture (Asio).
      */
    class AudioOutputDeviceAsio : public AudioOutputDevice {
        public:
            AudioOutputDeviceAsio(std::map<String,DeviceCreationParameter*> Parameters);
            ~AudioOutputDeviceAsio();

            // derived abstract methods from class 'AudioOutputDevice'
            virtual void Play();
            virtual bool IsPlaying();
            virtual void Stop();
            virtual uint MaxSamplesPerCycle();
            virtual uint SampleRate();
            virtual AudioChannel* CreateChannel(uint ChannelNr);

            virtual String Driver();
            static String Name();
            static String Description();
            static String Version();

            /** Device Parameter 'CARD'
                *
                * Used to select the desired Asio sound card.
                */
            class ParameterCard : public DeviceCreationParameterString {
                public:
                    ParameterCard();
                    ParameterCard(String s) throw (Exception);
                    virtual String Description();
                    virtual bool   Fix();
                    virtual bool   Mandatory();
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<String>    DefaultAsString(std::map<String,String> Parameters);
                    virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters);
                    virtual void                OnSetValue(String s) throw (Exception);
                    static String Name();
            };

            /** Device Parameter 'SAMPLERATE'
                *
                * Used to set the sample rate of the audio output device.
                */
            class ParameterSampleRate : public AudioOutputDevice::ParameterSampleRate {
                public:
                    ParameterSampleRate();
                    ParameterSampleRate(String s);
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
                                        virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
            };

            /** Device Parameters 'CHANNELS'
                *
                * Used to increase / decrease the number of audio channels of
                * audio output device.
                */
            class ParameterChannels : public AudioOutputDevice::ParameterChannels {
                public:
                    ParameterChannels();
                    ParameterChannels(String s);
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
                    virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters);
                    virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters);
            };


            /** Device Parameter 'FRAGMENTSIZE'
                *
                * Used to set the audio fragment size / period size.
                */
            class ParameterFragmentSize : public DeviceCreationParameterInt {
                public:
                    ParameterFragmentSize();
                    ParameterFragmentSize(String s) throw (Exception);
                    virtual String Description();
                    virtual bool   Fix();
                    virtual bool   Mandatory();
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters);
                    virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters);
                    virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters);
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
                    virtual void             OnSetValue(int i) throw (Exception);
                    static String Name();

            };

                        // make protected method public
                        AudioOutputDevice::RenderAudio;
            AudioOutputDevice::Channels;


        protected:
            int Main(); ///< Implementation of virtual method from class Thread

        private:
            uint                 uiAsioChannels;
            uint                 uiSamplerate;
            uint                 FragmentSize;
                        bool asioIsPlaying;

            static void bufferSwitch(long index, ASIOBool processNow);
            static ASIOTime* bufferSwitchTimeInfo(ASIOTime *timeInfo, long index, ASIOBool processNow);

    };
}

#endif // _LS_AUDIOOUTPUTDEVICEASIO_H_
1	senoner	1500	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6			* Copyright (C) 2005 - 2007 Christian Schoenebeck *
7			* *
8			* This program is free software; you can redistribute it and/or modify *
9			* it under the terms of the GNU General Public License as published by *
10			* the Free Software Foundation; either version 2 of the License, or *
11			* (at your option) any later version. *
12			* *
13			* This program is distributed in the hope that it will be useful, *
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16			* GNU General Public License for more details. *
17			* *
18			* You should have received a copy of the GNU General Public License *
19			* along with this program; if not, write to the Free Software *
20			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21			* MA 02111-1307 USA *
22			***************************************************************************/
23
24			#ifndef _LS_AUDIOOUTPUTDEVICEASIO_H_
25			#define _LS_AUDIOOUTPUTDEVICEASIO_H_
26
27			#include <string.h>
28
29			#include <asiosys.h>
30			#include <asio.h>
31			#include <asiodrivers.h>
32			#include <math.h>
33			#include "iasiothiscallresolver.h"
34
35			#include "../../common/global_private.h"
36			#include "AudioOutputDevice.h"
37			#include "AudioChannel.h"
38			#include "../DeviceParameter.h"
39
40			namespace LinuxSampler { //
41
42			/** Asio audio output driver
43			*
44			* Implements audio output to the Advanced Linux Sound Architecture (Asio).
45			*/
46			class AudioOutputDeviceAsio : public AudioOutputDevice {
47			public:
48			AudioOutputDeviceAsio(std::map<String,DeviceCreationParameter*> Parameters);
49			~AudioOutputDeviceAsio();
50
51			// derived abstract methods from class 'AudioOutputDevice'
52			virtual void Play();
53			virtual bool IsPlaying();
54			virtual void Stop();
55			virtual uint MaxSamplesPerCycle();
56			virtual uint SampleRate();
57			virtual AudioChannel* CreateChannel(uint ChannelNr);
58
59			virtual String Driver();
60			static String Name();
61			static String Description();
62			static String Version();
63
64			/** Device Parameter 'CARD'
65			*
66			* Used to select the desired Asio sound card.
67			*/
68			class ParameterCard : public DeviceCreationParameterString {
69			public:
70			ParameterCard();
71			ParameterCard(String s) throw (Exception);
72			virtual String Description();
73			virtual bool Fix();
74			virtual bool Mandatory();
75			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
76			virtual optional<String> DefaultAsString(std::map<String,String> Parameters);
77			virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters);
78			virtual void OnSetValue(String s) throw (Exception);
79			static String Name();
80			};
81
82			/** Device Parameter 'SAMPLERATE'
83			*
84			* Used to set the sample rate of the audio output device.
85			*/
86			class ParameterSampleRate : public AudioOutputDevice::ParameterSampleRate {
87			public:
88			ParameterSampleRate();
89			ParameterSampleRate(String s);
90			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
91			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
92			virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
93			};
94
95			/** Device Parameters 'CHANNELS'
96			*
97			* Used to increase / decrease the number of audio channels of
98			* audio output device.
99			*/
100			class ParameterChannels : public AudioOutputDevice::ParameterChannels {
101			public:
102			ParameterChannels();
103			ParameterChannels(String s);
104			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
105			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
106			virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters);
107			virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters);
108			};
109
110
111			/** Device Parameter 'FRAGMENTSIZE'
112			*
113			* Used to set the audio fragment size / period size.
114			*/
115			class ParameterFragmentSize : public DeviceCreationParameterInt {
116			public:
117			ParameterFragmentSize();
118			ParameterFragmentSize(String s) throw (Exception);
119			virtual String Description();
120			virtual bool Fix();
121			virtual bool Mandatory();
122			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
123			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
124			virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters);
125			virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters);
126			virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
127			virtual void OnSetValue(int i) throw (Exception);
128			static String Name();
129
130			};
131
132			// make protected method public
133			AudioOutputDevice::RenderAudio;
134			AudioOutputDevice::Channels;
135
136
137			protected:
138			int Main(); ///< Implementation of virtual method from class Thread
139
140			private:
141			uint uiAsioChannels;
142			uint uiSamplerate;
143			uint FragmentSize;
144			bool asioIsPlaying;
145
146			static void bufferSwitch(long index, ASIOBool processNow);
147			static ASIOTime* bufferSwitchTimeInfo(ASIOTime *timeInfo, long index, ASIOBool processNow);
148
149			};
150			}
151
152			#endif // _LS_AUDIOOUTPUTDEVICEASIO_H_