trunk/src/audioio.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 "audioio.h"

AudioIO::AudioIO() {
    pcm_handle    = NULL;
    pOutputBuffer = NULL;
    Initialized   = false;
    stream        = SND_PCM_STREAM_PLAYBACK;
}

AudioIO::~AudioIO() {
    Close();
}

int AudioIO::Initialize(uint channels, uint samplerate, uint numfragments, uint fragmentsize) {
    this->Channels     = channels;
    this->Samplerate   = samplerate;
    this->Fragments    = numfragments;
    this->FragmentSize = fragmentsize;

    if (HardwareParametersSupported(channels, samplerate, numfragments, fragmentsize)) {
        pcm_name = "hw:0,0";
    }
    else {
        printf("Warning: your soundcard doesn't support chosen hardware parameters; ");
        printf("trying to compensate support lack with plughw...");
        fflush(stdout);
        pcm_name = "plughw:0,0";
    }

    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 EXIT_FAILURE;
    }

    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 EXIT_FAILURE;
    }

    /* 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 EXIT_FAILURE;
    }

    /* Set sample format */
    if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE)) < 0) {
        fprintf(stderr, "Error setting sample format. : %s\n", snd_strerror(err));
        return EXIT_FAILURE;
    }

    /* Set sample rate. If the exact rate is not supported */
    /* by the hardware, use nearest possible rate.         */
    if((err = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, samplerate, 0)) < 0) {
        fprintf(stderr, "Error setting sample rate. : %s\n", snd_strerror(err));
        return EXIT_FAILURE;
    }

    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 EXIT_FAILURE;
    }

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

    /* 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 * numfragments))) < 0) {
        fprintf(stderr, "Error setting buffersize. : %s\n", snd_strerror(err));
        return EXIT_FAILURE;
    }

    /* 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 EXIT_FAILURE;
    }

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

    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 EXIT_FAILURE;
    }

    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 EXIT_FAILURE;
    }

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

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

    // allocate the audio output buffer
    pOutputBuffer = new int16_t[channels * fragmentsize];
    
    this->Initialized = true;

    return EXIT_SUCCESS;
}

/**
 *  Checks if sound card supports the chosen parameters.
 *
 *  @returns  true if hardware supports it
 */
bool AudioIO::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 (snd_pcm_hw_params_test_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE) < 0) {
        snd_pcm_close(pcm_handle);
        return false;
    }
    if (snd_pcm_hw_params_test_rate(pcm_handle, hwparams, samplerate, 0) < 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, 0) < 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;
}

int AudioIO::Output() {
    int err = snd_pcm_writei(pcm_handle, pOutputBuffer, FragmentSize);
    if (err < 0) {
        fprintf(stderr, "Error snd_pcm_writei failed. : %s\n", snd_strerror(err));
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

void AudioIO::Close(void) {
    if (Initialized) {
        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;
        }
        Initialized = false;
    }
}
1	/***************************************************************************
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 "audioio.h"
24
25	AudioIO::AudioIO() {
26	pcm_handle = NULL;
27	pOutputBuffer = NULL;
28	Initialized = false;
29	stream = SND_PCM_STREAM_PLAYBACK;
30	}
31
32	AudioIO::~AudioIO() {
33	Close();
34	}
35
36	int AudioIO::Initialize(uint channels, uint samplerate, uint numfragments, uint fragmentsize) {
37	this->Channels = channels;
38	this->Samplerate = samplerate;
39	this->Fragments = numfragments;
40	this->FragmentSize = fragmentsize;
41
42	if (HardwareParametersSupported(channels, samplerate, numfragments, fragmentsize)) {
43	pcm_name = "hw:0,0";
44	}
45	else {
46	printf("Warning: your soundcard doesn't support chosen hardware parameters; ");
47	printf("trying to compensate support lack with plughw...");
48	fflush(stdout);
49	pcm_name = "plughw:0,0";
50	}
51
52	int err;
53
54	snd_pcm_hw_params_alloca(&hwparams); // Allocate the snd_pcm_hw_params_t structure on the stack.
55
56	/* Open PCM. The last parameter of this function is the mode. */
57	/* If this is set to 0, the standard mode is used. Possible */
58	/* other values are SND_PCM_NONBLOCK and SND_PCM_ASYNC. */
59	/* If SND_PCM_NONBLOCK is used, read / write access to the */
60	/* PCM device will return immediately. If SND_PCM_ASYNC is */
61	/* specified, SIGIO will be emitted whenever a period has */
62	/* been completely processed by the soundcard. */
63	if ((err = snd_pcm_open(&pcm_handle, pcm_name.c_str(), stream, 0)) < 0) {
64	fprintf(stderr, "Error opening PCM device %s: %s\n", pcm_name.c_str(), snd_strerror(err));
65	return EXIT_FAILURE;
66	}
67
68	if ((err = snd_pcm_hw_params_any(pcm_handle, hwparams)) < 0) {
69	fprintf(stderr, "Error, cannot initialize hardware parameter structure: %s.\n", snd_strerror(err));
70	return EXIT_FAILURE;
71	}
72
73	/* Set access type. This can be either */
74	/* SND_PCM_ACCESS_RW_INTERLEAVED or */
75	/* SND_PCM_ACCESS_RW_NONINTERLEAVED. */
76	if ((err = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
77	fprintf(stderr, "Error snd_pcm_hw_params_set_access: %s.\n", snd_strerror(err));
78	return EXIT_FAILURE;
79	}
80
81	/* Set sample format */
82	if ((err = snd_pcm_hw_params_set_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE)) < 0) {
83	fprintf(stderr, "Error setting sample format. : %s\n", snd_strerror(err));
84	return EXIT_FAILURE;
85	}
86
87	/* Set sample rate. If the exact rate is not supported */
88	/* by the hardware, use nearest possible rate. */
89	if((err = snd_pcm_hw_params_set_rate_near(pcm_handle, hwparams, samplerate, 0)) < 0) {
90	fprintf(stderr, "Error setting sample rate. : %s\n", snd_strerror(err));
91	return EXIT_FAILURE;
92	}
93
94	if ((err = snd_pcm_hw_params_set_channels(pcm_handle, hwparams, channels)) < 0) {
95	fprintf(stderr, "Error setting number of channels. : %s\n", snd_strerror(err));
96	return EXIT_FAILURE;
97	}
98
99	/* Set number of periods. Periods used to be called fragments. */
100	if ((err = snd_pcm_hw_params_set_periods(pcm_handle, hwparams, numfragments, 0)) < 0) {
101	fprintf(stderr, "Error setting number of periods. : %s\n", snd_strerror(err));
102	return EXIT_FAILURE;
103	}
104
105	/* Set buffer size (in frames). The resulting latency is given by */
106	/* latency = periodsize * periods / (rate * bytes_per_frame) */
107	if ((err = snd_pcm_hw_params_set_buffer_size(pcm_handle, hwparams, (fragmentsize * numfragments))) < 0) {
108	fprintf(stderr, "Error setting buffersize. : %s\n", snd_strerror(err));
109	return EXIT_FAILURE;
110	}
111
112	/* Apply HW parameter settings to */
113	/* PCM device and prepare device */
114	if ((err = snd_pcm_hw_params(pcm_handle, hwparams)) < 0) {
115	fprintf(stderr, "Error setting HW params. : %s\n", snd_strerror(err));
116	return EXIT_FAILURE;
117	}
118
119	if (snd_pcm_sw_params_malloc(&swparams) != 0) {
120	fprintf(stderr, "Error in snd_pcm_sw_params_malloc. : %s\n", snd_strerror(err));
121	return EXIT_FAILURE;
122	}
123
124	if (snd_pcm_sw_params_current(pcm_handle, swparams) != 0) {
125	fprintf(stderr, "Error in snd_pcm_sw_params_current. : %s\n", snd_strerror(err));
126	return EXIT_FAILURE;
127	}
128
129	if (snd_pcm_sw_params_set_stop_threshold(pcm_handle, swparams, 0xffffffff) != 0) {
130	fprintf(stderr, "Error in snd_pcm_sw_params_set_stop_threshold. : %s\n", snd_strerror(err));
131	return EXIT_FAILURE;
132	}
133
134	if (snd_pcm_sw_params(pcm_handle, swparams) != 0) {
135	fprintf(stderr, "Error in snd_pcm_sw_params. : %s\n", snd_strerror(err));
136	return EXIT_FAILURE;
137	}
138
139	if ((err = snd_pcm_prepare(pcm_handle)) < 0) {
140	fprintf(stderr, "Error snd_pcm_prepare : %s\n", snd_strerror(err));
141	return EXIT_FAILURE;
142	}
143
144	// allocate the audio output buffer
145	pOutputBuffer = new int16_t[channels * fragmentsize];
146
147	this->Initialized = true;
148
149	return EXIT_SUCCESS;
150	}
151
152	/**
153	* Checks if sound card supports the chosen parameters.
154	*
155	* @returns true if hardware supports it
156	*/
157	bool AudioIO::HardwareParametersSupported(uint channels, int samplerate, uint numfragments, uint fragmentsize) {
158	pcm_name = "hw:0,0";
159	if (snd_pcm_open(&pcm_handle, pcm_name.c_str(), stream, 0) < 0) return false;
160	snd_pcm_hw_params_alloca(&hwparams);
161	if (snd_pcm_hw_params_any(pcm_handle, hwparams) < 0) {
162	snd_pcm_close(pcm_handle);
163	return false;
164	}
165	if (snd_pcm_hw_params_test_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
166	snd_pcm_close(pcm_handle);
167	return false;
168	}
169	if (snd_pcm_hw_params_test_format(pcm_handle, hwparams, SND_PCM_FORMAT_S16_LE) < 0) {
170	snd_pcm_close(pcm_handle);
171	return false;
172	}
173	if (snd_pcm_hw_params_test_rate(pcm_handle, hwparams, samplerate, 0) < 0) {
174	snd_pcm_close(pcm_handle);
175	return false;
176	}
177	if (snd_pcm_hw_params_test_channels(pcm_handle, hwparams, channels) < 0) {
178	snd_pcm_close(pcm_handle);
179	return false;
180	}
181	if (snd_pcm_hw_params_test_periods(pcm_handle, hwparams, numfragments, 0) < 0) {
182	snd_pcm_close(pcm_handle);
183	return false;
184	}
185	if (snd_pcm_hw_params_test_buffer_size(pcm_handle, hwparams, (fragmentsize * numfragments)) < 0) {
186	snd_pcm_close(pcm_handle);
187	return false;
188	}
189
190	snd_pcm_close(pcm_handle);
191	return true;
192	}
193
194	int AudioIO::Output() {
195	int err = snd_pcm_writei(pcm_handle, pOutputBuffer, FragmentSize);
196	if (err < 0) {
197	fprintf(stderr, "Error snd_pcm_writei failed. : %s\n", snd_strerror(err));
198	return EXIT_FAILURE;
199	}
200	return EXIT_SUCCESS;
201	}
202
203	void AudioIO::Close(void) {
204	if (Initialized) {
205	if (pcm_handle) {
206	//FIXME: currently commented out due to segfault
207	//snd_pcm_close(pcm_handle);
208	pcm_handle = NULL;
209	}
210	if (pOutputBuffer) {
211	//FIXME: currently commented out due to segfault
212	//delete[] pOutputBuffer;
213	pOutputBuffer = NULL;
214	}
215	Initialized = false;
216	}
217	}