singlechannel/src/alsaio.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003 by Benno Senoner and 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                                                   *
 ***************************************************************************/

#include "alsaio.h"

AlsaIO::AlsaIO() : AudioIO(), Thread(true, 1, 0) {
    pcm_handle    = NULL;
    pOutputBuffer = NULL;
    stream        = SND_PCM_STREAM_PLAYBACK;
}

int AlsaIO::Initialize(uint Channels, uint Samplerate, uint Fragments, uint FragmentSize, String Card) {
    this->uiChannels           = Channels;
    this->uiSamplerate         = Samplerate;
    this->uiMaxSamplesPerCycle = FragmentSize;
    this->bInterleaved         = true;

    if (HardwareParametersSupported(Channels, Samplerate, Fragments, FragmentSize)) {
        pcm_name = "hw:" + Card;
    }
    else {
        printf("Warning: your soundcard doesn't support chosen hardware parameters; ");
        printf("trying to compensate support lack with plughw...");
        fflush(stdout);
        pcm_name = "plughw:" + Card;
    }

    int err;

    snd_pcm_hw_params_alloca(&hwparams);  // Allocate the snd_pcm_hw_params_t structure on the stack.

    /* Open PCM. The last parameter of this function is the mode. */
    /* If this is set to 0, the standard mode is used. Possible   */
    /* other values are SND_PCM_NONBLOCK and SND_PCM_ASYNC.       */
    /* If SND_PCM_NONBLOCK is used, read / write access to the    */
    /* PCM device will return immediately. If SND_PCM_ASYNC is    */
    /* specified, SIGIO will be emitted whenever a period has     */
    /* been completely processed by the soundcard.                */
    if ((err = snd_pcm_open(&pcm_handle, pcm_name.c_str(), stream, 0)) < 0) {
        fprintf(stderr, "Error opening PCM device %s: %s\n", pcm_name.c_str(), snd_strerror(err));
        return -1;
    }

    if ((err = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0) {
        fprintf(stderr, "Error, cannot initialize hardware parameter structure: %s.\n", snd_strerror(err));
        return -1;
    }

    /* Set access type. This can be either    */
    /* SND_PCM_ACCESS_RW_INTERLEAVED or       */
    /* SND_PCM_ACCESS_RW_NONINTERLEAVED.      */
    if ((err = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
        fprintf(stderr, "Error snd_pcm_hw_params_set_access: %s.\n", snd_strerror(err));
        return -1;
    }

    /* Set sample format */
    #if WORDS_BIGENDIAN
    if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_BE)) < 0) {
    #else // little endian
    if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE)) < 0) {
    #endif
        fprintf(stderr, "Error setting sample format. : %s\n", snd_strerror(err));
        return -1;
    }

    int dir = 0;

    /* Set sample rate. If the exact rate is not supported */
    /* by the hardware, use nearest possible rate.         */
    #if ALSA_MAJOR > 0
    if((err = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &Samplerate, &dir)) < 0) {
    #else
    if((err = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, Samplerate, &dir)) < 0) {
    #endif
        fprintf(stderr, "Error setting sample rate. : %s\n", snd_strerror(err));
        return -1;
    }

    if ((err = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, Channels)) < 0) {
        fprintf(stderr, "Error setting number of channels. : %s\n", snd_strerror(err));
        return -1;
    }

    /* Set number of periods. Periods used to be called fragments. */
    if ((err = snd_pcm_hw_params_set_periods(pcm_handle, hwparams, Fragments, dir)) < 0) {
        fprintf(stderr, "Error setting number of periods. : %s\n", snd_strerror(err));
        return -1;
    }

    /* Set buffer size (in frames). The resulting latency is given by */
    /* latency = periodsize * periods / (rate * bytes_per_frame)     */
    if ((err = snd_pcm_hw_params_set_buffer_size(pcm_handle, hwparams, (FragmentSize * Fragments))) < 0) {
        fprintf(stderr, "Error setting buffersize. : %s\n", snd_strerror(err));
        return -1;
    }

    /* Apply HW parameter settings to */
    /* PCM device and prepare device  */
    if ((err = snd_pcm_hw_params(pcm_handle, hwparams)) < 0) {
        fprintf(stderr, "Error setting HW params. : %s\n", snd_strerror(err));
        return -1;
    }

    if (snd_pcm_sw_params_malloc(&swparams) != 0) {
        fprintf(stderr, "Error in snd_pcm_sw_params_malloc. : %s\n", snd_strerror(err));
        return -1;
    }

    if (snd_pcm_sw_params_current(pcm_handle, swparams) != 0) {
        fprintf(stderr, "Error in snd_pcm_sw_params_current. : %s\n", snd_strerror(err));
        return -1;
    }

    if (snd_pcm_sw_params_set_stop_threshold(pcm_handle, swparams, 0xffffffff) != 0) {
        fprintf(stderr, "Error in snd_pcm_sw_params_set_stop_threshold. : %s\n", snd_strerror(err));
        return -1;
    }

    if (snd_pcm_sw_params(pcm_handle, swparams) != 0) {
        fprintf(stderr, "Error in snd_pcm_sw_params. : %s\n", snd_strerror(err));
        return -1;
    }

    if ((err = snd_pcm_prepare(pcm_handle)) < 0) {
        fprintf(stderr, "Error snd_pcm_prepare : %s\n", snd_strerror(err));
        return -1;
    }

    // allocate the audio output buffer
    pOutputBuffer = new int16_t[Channels * FragmentSize];
    
    this->bInitialized = true;

    return 0;
}

/**
 *  Checks if sound card supports the chosen parameters.
 *
 *  @returns  true if hardware supports it
 */
bool AlsaIO::HardwareParametersSupported(uint channels, int samplerate, uint numfragments, uint fragmentsize) {
    pcm_name = "hw:0,0";
    if (snd_pcm_open(&pcm_handle, pcm_name.c_str(), stream, 0) < 0) return false;
    snd_pcm_hw_params_alloca(&hwparams);
    if (snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }
    if (snd_pcm_hw_params_test_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }
    #if WORDS_BIGENDIAN
    if (snd_pcm_hw_params_test_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_BE) < 0) {
    #else // little endian
    if (snd_pcm_hw_params_test_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE) < 0) {
    #endif
        snd_pcm_close(pcm_handle);
        return false;
    }
    int dir = 0;
    if (snd_pcm_hw_params_test_rate(pcm_handle, hwparams, samplerate, dir) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }
    if (snd_pcm_hw_params_test_channels(pcm_handle, hwparams, channels) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }
    if (snd_pcm_hw_params_test_periods(pcm_handle, hwparams, numfragments, dir) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }
    if (snd_pcm_hw_params_test_buffer_size(pcm_handle, hwparams, (fragmentsize * numfragments)) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }

    snd_pcm_close(pcm_handle);
    return true;
}

void AlsaIO::Activate() {
    this->StartThread();
}

int AlsaIO::Main() {
    if (!pEngine) {
        fprintf(stderr, "AlsaIO: No Sampler Engine assigned, exiting.\n");
        exit(EXIT_FAILURE);
    }
    if (!bInitialized) {
        fprintf(stderr, "AlsaIO: Not yet intitialized, exiting.\n");
        exit(EXIT_FAILURE);
    }

    while (true) {

        // let the engine render audio for the current audio fragment
        pEngine->RenderAudio(uiMaxSamplesPerCycle);


        // check clipping in the audio sum, convert to sample_type
        // (from 32bit to 16bit sample) and copy to output buffer
        float sample_point; uint o = 0;
        for (uint s = 0; s < uiMaxSamplesPerCycle; s++) {
            for (uint c = 0; c < uiChannels; c++) {
                sample_point = pEngine->GetAudioSumBuffer(c)[s] * pEngine->Volume;
                if (sample_point < -32768.0) sample_point = -32768.0;
                if (sample_point >  32767.0) sample_point =  32767.0;
                this->pOutputBuffer[o++] = (int32_t) sample_point;
            }
        }


        // output sound
        int res = Output();
        if (res < 0) {
            fprintf(stderr, "AlsaIO: Audio output error, exiting.\n");
            exit(EXIT_FAILURE);
        }
    }
}

/**
 *  Will be called after every audio fragment cycle, to output the audio data
 *  of the current fragment to the soundcard.
 *
 *  @returns  0 on success
 */
int AlsaIO::Output() {
    int err = snd_pcm_writei(pcm_handle, pOutputBuffer, uiMaxSamplesPerCycle);
    if (err < 0) {
        fprintf(stderr, "Error snd_pcm_writei failed. : %s\n", snd_strerror(err));
        return -1;
    }
    return 0;
}

void AlsaIO::Close() {
    if (bInitialized) {
        //dmsg(0,("Stopping Alsa Thread..."));
        //StopThread();  //FIXME: commented out due to a bug in thread.cpp (StopThread() doesn't return at all)
        //dmsg(0,("OK\n"));
        if (pcm_handle) {
            //FIXME: currently commented out due to segfault
            //snd_pcm_close(pcm_handle);
            pcm_handle = NULL;
        }
        if (pOutputBuffer) {
            //FIXME: currently commented out due to segfault
            //delete[] pOutputBuffer;
            pOutputBuffer = NULL;
        }
        bInitialized = false;
    }
}

void* AlsaIO::GetInterleavedOutputBuffer() {
    return pOutputBuffer;
}

void* AlsaIO::GetChannelOutputBufer(uint Channel) {
    fprintf(stderr, "AlsaIO::GetChannelOutputBufer(): Only interleaved access allowed so far, exiting.\n");
    exit(EXIT_FAILURE);
    // just to avoid compiler warnings
    return NULL;
}
1	schoenebeck	31	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003 by Benno Senoner and Christian Schoenebeck *
6			* *
7			* This program is free software; you can redistribute it and/or modify *
8			* it under the terms of the GNU General Public License as published by *
9			* the Free Software Foundation; either version 2 of the License, or *
10			* (at your option) any later version. *
11			* *
12			* This program is distributed in the hope that it will be useful, *
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15			* GNU General Public License for more details. *
16			* *
17			* You should have received a copy of the GNU General Public License *
18			* along with this program; if not, write to the Free Software *
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20			* MA 02111-1307 USA *
21			***************************************************************************/
22
23			#include "alsaio.h"
24
25			AlsaIO::AlsaIO() : AudioIO(), Thread(true, 1, 0) {
26			pcm_handle = NULL;
27			pOutputBuffer = NULL;
28			stream = SND_PCM_STREAM_PLAYBACK;
29			}
30
31	schoenebeck	33	int AlsaIO::Initialize(uint Channels, uint Samplerate, uint Fragments, uint FragmentSize, String Card) {
32	schoenebeck	31	this->uiChannels = Channels;
33			this->uiSamplerate = Samplerate;
34			this->uiMaxSamplesPerCycle = FragmentSize;
35			this->bInterleaved = true;
36
37			if (HardwareParametersSupported(Channels, Samplerate, Fragments, FragmentSize)) {
38	schoenebeck	33	pcm_name = "hw:" + Card;
39	schoenebeck	31	}
40			else {
41			printf("Warning: your soundcard doesn't support chosen hardware parameters; ");
42			printf("trying to compensate support lack with plughw...");
43			fflush(stdout);
44	schoenebeck	33	pcm_name = "plughw:" + Card;
45	schoenebeck	31	}
46
47			int err;
48
49			snd_pcm_hw_params_alloca(&hwparams); // Allocate the snd_pcm_hw_params_t structure on the stack.
50
51			/* Open PCM. The last parameter of this function is the mode. */
52			/* If this is set to 0, the standard mode is used. Possible */
53			/* other values are SND_PCM_NONBLOCK and SND_PCM_ASYNC. */
54			/* If SND_PCM_NONBLOCK is used, read / write access to the */
55			/* PCM device will return immediately. If SND_PCM_ASYNC is */
56			/* specified, SIGIO will be emitted whenever a period has */
57			/* been completely processed by the soundcard. */
58			if ((err = snd_pcm_open(&pcm_handle, pcm_name.c_str(), stream, 0)) < 0) {
59			fprintf(stderr, "Error opening PCM device %s: %s\n", pcm_name.c_str(), snd_strerror(err));
60			return -1;
61			}
62
63			if ((err = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0) {
64			fprintf(stderr, "Error, cannot initialize hardware parameter structure: %s.\n", snd_strerror(err));
65			return -1;
66			}
67
68			/* Set access type. This can be either */
69			/* SND_PCM_ACCESS_RW_INTERLEAVED or */
70			/* SND_PCM_ACCESS_RW_NONINTERLEAVED. */
71			if ((err = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
72			fprintf(stderr, "Error snd_pcm_hw_params_set_access: %s.\n", snd_strerror(err));
73			return -1;
74			}
75
76			/* Set sample format */
77			#if WORDS_BIGENDIAN
78			if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_BE)) < 0) {
79			#else // little endian
80			if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE)) < 0) {
81			#endif
82			fprintf(stderr, "Error setting sample format. : %s\n", snd_strerror(err));
83			return -1;
84			}
85
86			int dir = 0;
87
88			/* Set sample rate. If the exact rate is not supported */
89			/* by the hardware, use nearest possible rate. */
90			#if ALSA_MAJOR > 0
91			if((err = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, &Samplerate, &dir)) < 0) {
92			#else
93			if((err = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, Samplerate, &dir)) < 0) {
94			#endif
95			fprintf(stderr, "Error setting sample rate. : %s\n", snd_strerror(err));
96			return -1;
97			}
98
99			if ((err = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, Channels)) < 0) {
100			fprintf(stderr, "Error setting number of channels. : %s\n", snd_strerror(err));
101			return -1;
102			}
103
104			/* Set number of periods. Periods used to be called fragments. */
105			if ((err = snd_pcm_hw_params_set_periods(pcm_handle, hwparams, Fragments, dir)) < 0) {
106			fprintf(stderr, "Error setting number of periods. : %s\n", snd_strerror(err));
107			return -1;
108			}
109
110			/* Set buffer size (in frames). The resulting latency is given by */
111			/* latency = periodsize * periods / (rate * bytes_per_frame) */
112			if ((err = snd_pcm_hw_params_set_buffer_size(pcm_handle, hwparams, (FragmentSize * Fragments))) < 0) {
113			fprintf(stderr, "Error setting buffersize. : %s\n", snd_strerror(err));
114			return -1;
115			}
116
117			/* Apply HW parameter settings to */
118			/* PCM device and prepare device */
119			if ((err = snd_pcm_hw_params(pcm_handle, hwparams)) < 0) {
120			fprintf(stderr, "Error setting HW params. : %s\n", snd_strerror(err));
121			return -1;
122			}
123
124			if (snd_pcm_sw_params_malloc(&swparams) != 0) {
125			fprintf(stderr, "Error in snd_pcm_sw_params_malloc. : %s\n", snd_strerror(err));
126			return -1;
127			}
128
129			if (snd_pcm_sw_params_current(pcm_handle, swparams) != 0) {
130			fprintf(stderr, "Error in snd_pcm_sw_params_current. : %s\n", snd_strerror(err));
131			return -1;
132			}
133
134			if (snd_pcm_sw_params_set_stop_threshold(pcm_handle, swparams, 0xffffffff) != 0) {
135			fprintf(stderr, "Error in snd_pcm_sw_params_set_stop_threshold. : %s\n", snd_strerror(err));
136			return -1;
137			}
138
139			if (snd_pcm_sw_params(pcm_handle, swparams) != 0) {
140			fprintf(stderr, "Error in snd_pcm_sw_params. : %s\n", snd_strerror(err));
141			return -1;
142			}
143
144			if ((err = snd_pcm_prepare(pcm_handle)) < 0) {
145			fprintf(stderr, "Error snd_pcm_prepare : %s\n", snd_strerror(err));
146			return -1;
147			}
148
149			// allocate the audio output buffer
150			pOutputBuffer = new int16_t[Channels * FragmentSize];
151
152			this->bInitialized = true;
153
154			return 0;
155			}
156
157			/**
158			* Checks if sound card supports the chosen parameters.
159			*
160			* @returns true if hardware supports it
161			*/
162			bool AlsaIO::HardwareParametersSupported(uint channels, int samplerate, uint numfragments, uint fragmentsize) {
163			pcm_name = "hw:0,0";
164			if (snd_pcm_open(&pcm_handle, pcm_name.c_str(), stream, 0) < 0) return false;
165			snd_pcm_hw_params_alloca(&hwparams);
166			if (snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) {
167			snd_pcm_close(pcm_handle);
168			return false;
169			}
170			if (snd_pcm_hw_params_test_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
171			snd_pcm_close(pcm_handle);
172			return false;
173			}
174			#if WORDS_BIGENDIAN
175			if (snd_pcm_hw_params_test_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_BE) < 0) {
176			#else // little endian
177			if (snd_pcm_hw_params_test_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE) < 0) {
178			#endif
179			snd_pcm_close(pcm_handle);
180			return false;
181			}
182			int dir = 0;
183			if (snd_pcm_hw_params_test_rate(pcm_handle, hwparams, samplerate, dir) < 0) {
184			snd_pcm_close(pcm_handle);
185			return false;
186			}
187			if (snd_pcm_hw_params_test_channels(pcm_handle, hwparams, channels) < 0) {
188			snd_pcm_close(pcm_handle);
189			return false;
190			}
191			if (snd_pcm_hw_params_test_periods(pcm_handle, hwparams, numfragments, dir) < 0) {
192			snd_pcm_close(pcm_handle);
193			return false;
194			}
195			if (snd_pcm_hw_params_test_buffer_size(pcm_handle, hwparams, (fragmentsize * numfragments)) < 0) {
196			snd_pcm_close(pcm_handle);
197			return false;
198			}
199
200			snd_pcm_close(pcm_handle);
201			return true;
202			}
203
204			void AlsaIO::Activate() {
205			this->StartThread();
206			}
207
208			int AlsaIO::Main() {
209			if (!pEngine) {
210			fprintf(stderr, "AlsaIO: No Sampler Engine assigned, exiting.\n");
211			exit(EXIT_FAILURE);
212			}
213			if (!bInitialized) {
214			fprintf(stderr, "AlsaIO: Not yet intitialized, exiting.\n");
215			exit(EXIT_FAILURE);
216			}
217
218			while (true) {
219
220			// let the engine render audio for the current audio fragment
221			pEngine->RenderAudio(uiMaxSamplesPerCycle);
222
223
224			// check clipping in the audio sum, convert to sample_type
225			// (from 32bit to 16bit sample) and copy to output buffer
226			float sample_point; uint o = 0;
227			for (uint s = 0; s < uiMaxSamplesPerCycle; s++) {
228			for (uint c = 0; c < uiChannels; c++) {
229			sample_point = pEngine->GetAudioSumBuffer(c)[s] * pEngine->Volume;
230			if (sample_point < -32768.0) sample_point = -32768.0;
231			if (sample_point > 32767.0) sample_point = 32767.0;
232			this->pOutputBuffer[o++] = (int32_t) sample_point;
233			}
234			}
235
236
237			// output sound
238			int res = Output();
239			if (res < 0) {
240			fprintf(stderr, "AlsaIO: Audio output error, exiting.\n");
241			exit(EXIT_FAILURE);
242			}
243			}
244			}
245
246			/**
247			* Will be called after every audio fragment cycle, to output the audio data
248			* of the current fragment to the soundcard.
249			*
250			* @returns 0 on success
251			*/
252			int AlsaIO::Output() {
253			int err = snd_pcm_writei(pcm_handle, pOutputBuffer, uiMaxSamplesPerCycle);
254			if (err < 0) {
255			fprintf(stderr, "Error snd_pcm_writei failed. : %s\n", snd_strerror(err));
256			return -1;
257			}
258			return 0;
259			}
260
261			void AlsaIO::Close() {
262			if (bInitialized) {
263			//dmsg(0,("Stopping Alsa Thread..."));
264			//StopThread(); //FIXME: commented out due to a bug in thread.cpp (StopThread() doesn't return at all)
265			//dmsg(0,("OK\n"));
266			if (pcm_handle) {
267			//FIXME: currently commented out due to segfault
268			//snd_pcm_close(pcm_handle);
269			pcm_handle = NULL;
270			}
271			if (pOutputBuffer) {
272			//FIXME: currently commented out due to segfault
273			//delete[] pOutputBuffer;
274			pOutputBuffer = NULL;
275			}
276			bInitialized = false;
277			}
278			}
279
280			void* AlsaIO::GetInterleavedOutputBuffer() {
281			return pOutputBuffer;
282			}
283
284			void* AlsaIO::GetChannelOutputBufer(uint Channel) {
285			fprintf(stderr, "AlsaIO::GetChannelOutputBufer(): Only interleaved access allowed so far, exiting.\n");
286			exit(EXIT_FAILURE);
287			// just to avoid compiler warnings
288			return NULL;
289			}