]> code.delx.au - pulseaudio/blob - src/utils/paplay.c
when playing an ULAW or ALAW audio file, do not convert to S16NE unconditionally...
[pulseaudio] / src / utils / paplay.c
1 /* $Id$ */
2
3 /***
4 This file is part of polypaudio.
5
6 polypaudio is free software; you can redistribute it and/or modify
7 it under the terms of the GNU Lesser General Public License as published
8 by the Free Software Foundation; either version 2 of the License,
9 or (at your option) any later version.
10
11 polypaudio is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License
17 along with polypaudio; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19 USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <signal.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <unistd.h>
30 #include <assert.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <getopt.h>
34
35 #include <sndfile.h>
36
37 #include <polyp/polypaudio.h>
38 #include <polyp/mainloop.h>
39 #include <polyp/mainloop-signal.h>
40
41 #if PA_API_VERSION != 9
42 #error Invalid Polypaudio API version
43 #endif
44
45 static pa_context *context = NULL;
46 static pa_stream *stream = NULL;
47 static pa_mainloop_api *mainloop_api = NULL;
48
49 static char *stream_name = NULL, *client_name = NULL, *device = NULL;
50
51 static int verbose = 0;
52 static pa_volume_t volume = PA_VOLUME_NORM;
53
54 static SNDFILE* sndfile = NULL;
55
56 static pa_sample_spec sample_spec = { 0, 0, 0 };
57 static pa_channel_map channel_map;
58 static int channel_map_set = 0;
59
60 static sf_count_t (*readf_function)(SNDFILE *_sndfile, void *ptr, sf_count_t frames) = NULL;
61
62 /* A shortcut for terminating the application */
63 static void quit(int ret) {
64 assert(mainloop_api);
65 mainloop_api->quit(mainloop_api, ret);
66 }
67
68 /* Connection draining complete */
69 static void context_drain_complete(pa_context*c, void *userdata) {
70 pa_context_disconnect(c);
71 }
72
73 /* Stream draining complete */
74 static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
75 pa_operation *o;
76
77 if (!success) {
78 fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
79 quit(1);
80 }
81
82 if (verbose)
83 fprintf(stderr, "Playback stream drained.\n");
84
85 pa_stream_disconnect(stream);
86 pa_stream_unref(stream);
87 stream = NULL;
88
89 if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
90 pa_context_disconnect(context);
91 else {
92 pa_operation_unref(o);
93
94 if (verbose)
95 fprintf(stderr, "Draining connection to server.\n");
96 }
97 }
98
99 /* This is called whenever new data may be written to the stream */
100 static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
101 sf_count_t bytes;
102 void *data;
103 assert(s && length);
104
105 if (!sndfile)
106 return;
107
108 data = malloc(length);
109
110 if (readf_function) {
111 size_t k = pa_frame_size(&sample_spec);
112
113 if ((bytes = readf_function(sndfile, data, length/k)) > 0)
114 bytes *= k;
115
116 } else
117 bytes = sf_read_raw(sndfile, data, length);
118
119 if (bytes > 0)
120 pa_stream_write(s, data, bytes, free, 0, PA_SEEK_RELATIVE);
121 else
122 free(data);
123
124 if (bytes < length) {
125 sf_close(sndfile);
126 sndfile = NULL;
127 pa_operation_unref(pa_stream_drain(s, stream_drain_complete, NULL));
128 }
129 }
130
131 /* This routine is called whenever the stream state changes */
132 static void stream_state_callback(pa_stream *s, void *userdata) {
133 assert(s);
134
135 switch (pa_stream_get_state(s)) {
136 case PA_STREAM_CREATING:
137 case PA_STREAM_TERMINATED:
138 break;
139
140 case PA_STREAM_READY:
141 if (verbose)
142 fprintf(stderr, "Stream successfully created\n");
143 break;
144
145 case PA_STREAM_FAILED:
146 default:
147 fprintf(stderr, "Stream errror: %s\n", pa_strerror(pa_context_errno(pa_stream_get_context(s))));
148 quit(1);
149 }
150 }
151
152 /* This is called whenever the context status changes */
153 static void context_state_callback(pa_context *c, void *userdata) {
154 assert(c);
155
156 switch (pa_context_get_state(c)) {
157 case PA_CONTEXT_CONNECTING:
158 case PA_CONTEXT_AUTHORIZING:
159 case PA_CONTEXT_SETTING_NAME:
160 break;
161
162 case PA_CONTEXT_READY: {
163 pa_cvolume cv;
164
165 assert(c && !stream);
166
167 if (verbose)
168 fprintf(stderr, "Connection established.\n");
169
170 stream = pa_stream_new(c, stream_name, &sample_spec, channel_map_set ? &channel_map : NULL);
171 assert(stream);
172
173 pa_stream_set_state_callback(stream, stream_state_callback, NULL);
174 pa_stream_set_write_callback(stream, stream_write_callback, NULL);
175 pa_stream_connect_playback(stream, device, NULL, 0, pa_cvolume_set(&cv, sample_spec.channels, volume), NULL);
176
177 break;
178 }
179
180 case PA_CONTEXT_TERMINATED:
181 quit(0);
182 break;
183
184 case PA_CONTEXT_FAILED:
185 default:
186 fprintf(stderr, "Connection failure: %s\n", pa_strerror(pa_context_errno(c)));
187 quit(1);
188 }
189 }
190
191 /* UNIX signal to quit recieved */
192 static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
193 if (verbose)
194 fprintf(stderr, "Got SIGINT, exiting.\n");
195 quit(0);
196
197 }
198
199 static void help(const char *argv0) {
200
201 printf("%s [options] [FILE]\n\n"
202 " -h, --help Show this help\n"
203 " --version Show version\n\n"
204 " -v, --verbose Enable verbose operations\n\n"
205 " -s, --server=SERVER The name of the server to connect to\n"
206 " -d, --device=DEVICE The name of the sink/source to connect to\n"
207 " -n, --client-name=NAME How to call this client on the server\n"
208 " --stream-name=NAME How to call this stream on the server\n"
209 " --volume=VOLUME Specify the initial (linear) volume in range 0...65536\n"
210 " --channel-map=CHANNELMAP Set the channel map to the use\n",
211 argv0);
212 }
213
214 enum {
215 ARG_VERSION = 256,
216 ARG_STREAM_NAME,
217 ARG_VOLUME,
218 ARG_CHANNELMAP
219 };
220
221 int main(int argc, char *argv[]) {
222 pa_mainloop* m = NULL;
223 int ret = 1, r, c;
224 char *bn, *server = NULL;
225 const char *filename;
226 SF_INFO sfinfo;
227
228 static const struct option long_options[] = {
229 {"device", 1, NULL, 'd'},
230 {"server", 1, NULL, 's'},
231 {"client-name", 1, NULL, 'n'},
232 {"stream-name", 1, NULL, ARG_STREAM_NAME},
233 {"version", 0, NULL, ARG_VERSION},
234 {"help", 0, NULL, 'h'},
235 {"verbose", 0, NULL, 'v'},
236 {"volume", 1, NULL, ARG_VOLUME},
237 {"channel-map", 1, NULL, ARG_CHANNELMAP},
238 {NULL, 0, NULL, 0}
239 };
240
241 if (!(bn = strrchr(argv[0], '/')))
242 bn = argv[0];
243 else
244 bn++;
245
246 while ((c = getopt_long(argc, argv, "d:s:n:hv", long_options, NULL)) != -1) {
247
248 switch (c) {
249 case 'h' :
250 help(bn);
251 ret = 0;
252 goto quit;
253
254 case ARG_VERSION:
255 printf("paplay "PACKAGE_VERSION"\nCompiled with libpolyp %s\nLinked with libpolyp %s\n", pa_get_headers_version(), pa_get_library_version());
256 ret = 0;
257 goto quit;
258
259 case 'd':
260 free(device);
261 device = strdup(optarg);
262 break;
263
264 case 's':
265 free(server);
266 server = strdup(optarg);
267 break;
268
269 case 'n':
270 free(client_name);
271 client_name = strdup(optarg);
272 break;
273
274 case ARG_STREAM_NAME:
275 free(stream_name);
276 stream_name = strdup(optarg);
277 break;
278
279 case 'v':
280 verbose = 1;
281 break;
282
283 case ARG_VOLUME: {
284 int v = atoi(optarg);
285 volume = v < 0 ? 0 : v;
286 break;
287 }
288
289 case ARG_CHANNELMAP:
290 if (!pa_channel_map_parse(&channel_map, optarg)) {
291 fprintf(stderr, "Invalid channel map\n");
292 goto quit;
293 }
294
295 channel_map_set = 1;
296 break;
297
298 default:
299 goto quit;
300 }
301 }
302
303 filename = optind < argc ? argv[optind] : "STDIN";
304
305 memset(&sfinfo, 0, sizeof(sfinfo));
306
307 if (optind < argc)
308 sndfile = sf_open(filename, SFM_READ, &sfinfo);
309 else
310 sndfile = sf_open_fd(STDIN_FILENO, SFM_READ, &sfinfo, 0);
311
312 if (!sndfile) {
313 fprintf(stderr, "Failed to open file '%s'\n", filename);
314 goto quit;
315 }
316
317 sample_spec.rate = sfinfo.samplerate;
318 sample_spec.channels = sfinfo.channels;
319
320 switch (sfinfo.format & 0xFF) {
321 case SF_FORMAT_PCM_16:
322 case SF_FORMAT_PCM_U8:
323 sample_spec.format = PA_SAMPLE_S16NE;
324 readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_short;
325 break;
326
327 case SF_FORMAT_ULAW:
328 sample_spec.format = PA_SAMPLE_ULAW;
329 readf_function = NULL;
330 break;
331
332 case SF_FORMAT_ALAW:
333 sample_spec.format = PA_SAMPLE_ALAW;
334 readf_function = NULL;
335 break;
336
337 case SF_FORMAT_FLOAT:
338 default:
339 sample_spec.format = PA_SAMPLE_FLOAT32NE;
340 readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_float;
341 break;
342 }
343
344 assert(pa_sample_spec_valid(&sample_spec));
345
346 if (channel_map_set && channel_map.channels != sample_spec.channels) {
347 fprintf(stderr, "Channel map doesn't match file.\n");
348 goto quit;
349 }
350
351 if (!client_name)
352 client_name = strdup(bn);
353
354 if (!stream_name) {
355 const char *n = sf_get_string(sndfile, SF_STR_TITLE);
356 stream_name = strdup(n ? n : filename);
357 }
358
359 if (verbose) {
360 char t[PA_SAMPLE_SPEC_SNPRINT_MAX];
361 pa_sample_spec_snprint(t, sizeof(t), &sample_spec);
362 fprintf(stderr, "Using sample spec '%s'\n", t);
363 }
364
365 /* Set up a new main loop */
366 if (!(m = pa_mainloop_new())) {
367 fprintf(stderr, "pa_mainloop_new() failed.\n");
368 goto quit;
369 }
370
371 mainloop_api = pa_mainloop_get_api(m);
372
373 r = pa_signal_init(mainloop_api);
374 assert(r == 0);
375 pa_signal_new(SIGINT, exit_signal_callback, NULL);
376 #ifdef SIGPIPE
377 signal(SIGPIPE, SIG_IGN);
378 #endif
379
380 /* Create a new connection context */
381 if (!(context = pa_context_new(mainloop_api, client_name))) {
382 fprintf(stderr, "pa_context_new() failed.\n");
383 goto quit;
384 }
385
386 pa_context_set_state_callback(context, context_state_callback, NULL);
387
388 /* Connect the context */
389 pa_context_connect(context, server, 0, NULL);
390
391 /* Run the main loop */
392 if (pa_mainloop_run(m, &ret) < 0) {
393 fprintf(stderr, "pa_mainloop_run() failed.\n");
394 goto quit;
395 }
396
397 quit:
398 if (stream)
399 pa_stream_unref(stream);
400
401 if (context)
402 pa_context_unref(context);
403
404 if (m) {
405 pa_signal_done();
406 pa_mainloop_free(m);
407 }
408
409 free(server);
410 free(device);
411 free(client_name);
412 free(stream_name);
413
414 if (sndfile)
415 sf_close(sndfile);
416
417 return ret;
418 }