1 /* GStreamer
2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3 * 2000,2005 Wim Taymans <wim@fluendo.com>
4 *
5 * gstosssink.c:
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library 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 GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
21 */
22
23 /**
24 * SECTION:element-osssink
25 *
26 * This element lets you output sound using the Open Sound System (OSS).
27 *
28 * Note that you should almost always use generic audio conversion elements
29 * like audioconvert and audioresample in front of an audiosink to make sure
30 * your pipeline works under all circumstances (those conversion elements will
31 * act in passthrough-mode if no conversion is necessary).
32 *
33 * <refsect2>
34 * <title>Example pipelines</title>
35 * |[
36 * gst-launch-1.0 -v audiotestsrc ! audioconvert ! volume volume=0.1 ! osssink
37 * ]| will output a sine wave (continuous beep sound) to your sound card (with
38 * a very low volume as precaution).
39 * |[
40 * gst-launch-1.0 -v filesrc location=music.ogg ! decodebin ! audioconvert ! audioresample ! osssink
41 * ]| will play an Ogg/Vorbis audio file and output it using the Open Sound System.
42 * </refsect2>
43 */
44
45 #ifdef HAVE_CONFIG_H
46 #include "config.h"
47 #endif
48 #include <sys/ioctl.h>
49 #include <fcntl.h>
50 #include <errno.h>
51 #include <unistd.h>
52 #include <string.h>
53
54 #ifdef HAVE_OSS_INCLUDE_IN_SYS
55 # include <sys/soundcard.h>
56 #else
57 # ifdef HAVE_OSS_INCLUDE_IN_ROOT
58 # include <soundcard.h>
59 # else
60 # ifdef HAVE_OSS_INCLUDE_IN_MACHINE
61 # include <machine/soundcard.h>
62 # else
63 # error "What to include?"
64 # endif /* HAVE_OSS_INCLUDE_IN_MACHINE */
65 # endif /* HAVE_OSS_INCLUDE_IN_ROOT */
66 #endif /* HAVE_OSS_INCLUDE_IN_SYS */
67
68 #include "common.h"
69 #include "gstosssink.h"
70
71 #include <gst/gst-i18n-plugin.h>
72
73 GST_DEBUG_CATEGORY_EXTERN (oss_debug);
74 #define GST_CAT_DEFAULT oss_debug
75
76 static void gst_oss_sink_dispose (GObject * object);
77 static void gst_oss_sink_finalise (GObject * object);
78
79 static void gst_oss_sink_get_property (GObject * object, guint prop_id,
80 GValue * value, GParamSpec * pspec);
81 static void gst_oss_sink_set_property (GObject * object, guint prop_id,
82 const GValue * value, GParamSpec * pspec);
83
84 static GstCaps *gst_oss_sink_getcaps (GstBaseSink * bsink, GstCaps * filter);
85
86 static gboolean gst_oss_sink_open (GstAudioSink * asink);
87 static gboolean gst_oss_sink_close (GstAudioSink * asink);
88 static gboolean gst_oss_sink_prepare (GstAudioSink * asink,
89 GstAudioRingBufferSpec * spec);
90 static gboolean gst_oss_sink_unprepare (GstAudioSink * asink);
91 static gint gst_oss_sink_write (GstAudioSink * asink, gpointer data,
92 guint length);
93 static guint gst_oss_sink_delay (GstAudioSink * asink);
94 static void gst_oss_sink_reset (GstAudioSink * asink);
95
96 /* OssSink signals and args */
97 enum
98 {
99 LAST_SIGNAL
100 };
101
102 #define DEFAULT_DEVICE "/dev/dsp"
103 enum
104 {
105 PROP_0,
106 PROP_DEVICE,
107 };
108
109 #define FORMATS "{" GST_AUDIO_NE(S32)","GST_AUDIO_NE(U32)"," \
110 GST_AUDIO_NE(S24)","GST_AUDIO_NE(U24)"," \
111 GST_AUDIO_NE(S16)","GST_AUDIO_NE(U16)"," \
112 "S8, U8 }"
113
114 static GstStaticPadTemplate osssink_sink_factory =
115 GST_STATIC_PAD_TEMPLATE ("sink",
116 GST_PAD_SINK,
117 GST_PAD_ALWAYS,
118 GST_STATIC_CAPS ("audio/x-raw, "
119 "format = (string) " FORMATS ", "
120 "layout = (string) interleaved, "
121 "rate = (int) [ 1, MAX ], "
122 "channels = (int) 1; "
123 "audio/x-raw, "
124 "format = (string) " FORMATS ", "
125 "layout = (string) interleaved, "
126 "rate = (int) [ 1, MAX ], "
127 "channels = (int) 2, " "channel-mask = (bitmask) 0x3")
128 );
129
130 /* static guint gst_oss_sink_signals[LAST_SIGNAL] = { 0 }; */
131
132 #define gst_oss_sink_parent_class parent_class
133 G_DEFINE_TYPE (GstOssSink, gst_oss_sink, GST_TYPE_AUDIO_SINK);
134
135 static void
gst_oss_sink_dispose(GObject * object)136 gst_oss_sink_dispose (GObject * object)
137 {
138 GstOssSink *osssink = GST_OSSSINK (object);
139
140 if (osssink->probed_caps) {
141 gst_caps_unref (osssink->probed_caps);
142 osssink->probed_caps = NULL;
143 }
144
145 G_OBJECT_CLASS (parent_class)->dispose (object);
146 }
147
148 static void
gst_oss_sink_class_init(GstOssSinkClass * klass)149 gst_oss_sink_class_init (GstOssSinkClass * klass)
150 {
151 GObjectClass *gobject_class;
152 GstElementClass *gstelement_class;
153 GstBaseSinkClass *gstbasesink_class;
154 GstAudioSinkClass *gstaudiosink_class;
155
156 gobject_class = (GObjectClass *) klass;
157 gstelement_class = (GstElementClass *) klass;
158 gstbasesink_class = (GstBaseSinkClass *) klass;
159 gstaudiosink_class = (GstAudioSinkClass *) klass;
160
161 parent_class = g_type_class_peek_parent (klass);
162
163 gobject_class->dispose = gst_oss_sink_dispose;
164 gobject_class->finalize = gst_oss_sink_finalise;
165 gobject_class->get_property = gst_oss_sink_get_property;
166 gobject_class->set_property = gst_oss_sink_set_property;
167
168 g_object_class_install_property (gobject_class, PROP_DEVICE,
169 g_param_spec_string ("device", "Device",
170 "OSS device (usually /dev/dspN)", DEFAULT_DEVICE,
171 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
172
173 gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss_sink_getcaps);
174
175 gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_oss_sink_open);
176 gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_oss_sink_close);
177 gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_oss_sink_prepare);
178 gstaudiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss_sink_unprepare);
179 gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_oss_sink_write);
180 gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_oss_sink_delay);
181 gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_oss_sink_reset);
182
183 gst_element_class_set_static_metadata (gstelement_class, "Audio Sink (OSS)",
184 "Sink/Audio",
185 "Output to a sound card via OSS",
186 "Erik Walthinsen <omega@cse.ogi.edu>, "
187 "Wim Taymans <wim.taymans@chello.be>");
188
189 gst_element_class_add_static_pad_template (gstelement_class,
190 &osssink_sink_factory);
191 }
192
193 static void
gst_oss_sink_init(GstOssSink * osssink)194 gst_oss_sink_init (GstOssSink * osssink)
195 {
196 const gchar *device;
197
198 GST_DEBUG_OBJECT (osssink, "initializing osssink");
199
200 device = g_getenv ("AUDIODEV");
201 if (device == NULL)
202 device = DEFAULT_DEVICE;
203 osssink->device = g_strdup (device);
204 osssink->fd = -1;
205 }
206
207 static void
gst_oss_sink_finalise(GObject * object)208 gst_oss_sink_finalise (GObject * object)
209 {
210 GstOssSink *osssink = GST_OSSSINK (object);
211
212 g_free (osssink->device);
213
214 G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (object));
215 }
216
217 static void
gst_oss_sink_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)218 gst_oss_sink_set_property (GObject * object, guint prop_id,
219 const GValue * value, GParamSpec * pspec)
220 {
221 GstOssSink *sink;
222
223 sink = GST_OSSSINK (object);
224
225 switch (prop_id) {
226 case PROP_DEVICE:
227 g_free (sink->device);
228 sink->device = g_value_dup_string (value);
229 if (sink->probed_caps) {
230 gst_caps_unref (sink->probed_caps);
231 sink->probed_caps = NULL;
232 }
233 break;
234 default:
235 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
236 break;
237 }
238 }
239
240 static void
gst_oss_sink_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)241 gst_oss_sink_get_property (GObject * object, guint prop_id,
242 GValue * value, GParamSpec * pspec)
243 {
244 GstOssSink *sink;
245
246 sink = GST_OSSSINK (object);
247
248 switch (prop_id) {
249 case PROP_DEVICE:
250 g_value_set_string (value, sink->device);
251 break;
252 default:
253 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
254 break;
255 }
256 }
257
258 static GstCaps *
gst_oss_sink_getcaps(GstBaseSink * bsink,GstCaps * filter)259 gst_oss_sink_getcaps (GstBaseSink * bsink, GstCaps * filter)
260 {
261 GstOssSink *osssink;
262 GstCaps *caps;
263
264 osssink = GST_OSSSINK (bsink);
265
266 if (osssink->fd == -1) {
267 caps = gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD (bsink));
268 } else if (osssink->probed_caps) {
269 caps = gst_caps_ref (osssink->probed_caps);
270 } else {
271 caps = gst_oss_helper_probe_caps (osssink->fd);
272 if (caps && !gst_caps_is_empty (caps)) {
273 osssink->probed_caps = gst_caps_ref (caps);
274 }
275 }
276
277 if (filter && caps) {
278 GstCaps *intersection;
279
280 intersection =
281 gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
282 gst_caps_unref (caps);
283 return intersection;
284 } else {
285 return caps;
286 }
287 }
288
289 static gint
ilog2(gint x)290 ilog2 (gint x)
291 {
292 /* well... hacker's delight explains... */
293 x = x | (x >> 1);
294 x = x | (x >> 2);
295 x = x | (x >> 4);
296 x = x | (x >> 8);
297 x = x | (x >> 16);
298 x = x - ((x >> 1) & 0x55555555);
299 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
300 x = (x + (x >> 4)) & 0x0f0f0f0f;
301 x = x + (x >> 8);
302 x = x + (x >> 16);
303 return (x & 0x0000003f) - 1;
304 }
305
306 static gint
gst_oss_sink_get_format(GstAudioRingBufferFormatType fmt,GstAudioFormat rfmt)307 gst_oss_sink_get_format (GstAudioRingBufferFormatType fmt, GstAudioFormat rfmt)
308 {
309 gint result;
310
311 switch (fmt) {
312 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW:
313 result = AFMT_MU_LAW;
314 break;
315 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW:
316 result = AFMT_A_LAW;
317 break;
318 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM:
319 result = AFMT_IMA_ADPCM;
320 break;
321 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG:
322 result = AFMT_MPEG;
323 break;
324 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW:
325 {
326 switch (rfmt) {
327 case GST_AUDIO_FORMAT_S8:
328 result = AFMT_S8;
329 break;
330 case GST_AUDIO_FORMAT_U8:
331 result = AFMT_U8;
332 break;
333 case GST_AUDIO_FORMAT_S16LE:
334 result = AFMT_S16_LE;
335 break;
336 case GST_AUDIO_FORMAT_S16BE:
337 result = AFMT_S16_BE;
338 break;
339 case GST_AUDIO_FORMAT_U16LE:
340 result = AFMT_U16_LE;
341 break;
342 case GST_AUDIO_FORMAT_U16BE:
343 result = AFMT_U16_BE;
344 break;
345 case GST_AUDIO_FORMAT_S24LE:
346 result = AFMT_S24_LE;
347 break;
348 case GST_AUDIO_FORMAT_S24BE:
349 result = AFMT_S24_BE;
350 break;
351 case GST_AUDIO_FORMAT_U24LE:
352 result = AFMT_U24_LE;
353 break;
354 case GST_AUDIO_FORMAT_U24BE:
355 result = AFMT_U24_BE;
356 break;
357 case GST_AUDIO_FORMAT_S32LE:
358 result = AFMT_S32_LE;
359 break;
360 case GST_AUDIO_FORMAT_S32BE:
361 result = AFMT_S32_BE;
362 break;
363 case GST_AUDIO_FORMAT_U32LE:
364 result = AFMT_U32_LE;
365 break;
366 case GST_AUDIO_FORMAT_U32BE:
367 result = AFMT_U32_BE;
368 break;
369 default:
370 result = 0;
371 break;
372 }
373 break;
374 }
375 default:
376 result = 0;
377 break;
378 }
379 return result;
380 }
381
382 static gboolean
gst_oss_sink_open(GstAudioSink * asink)383 gst_oss_sink_open (GstAudioSink * asink)
384 {
385 GstOssSink *oss;
386 int mode;
387
388 oss = GST_OSSSINK (asink);
389
390 mode = O_WRONLY;
391 mode |= O_NONBLOCK;
392
393 oss->fd = open (oss->device, mode, 0);
394 if (oss->fd == -1) {
395 switch (errno) {
396 case EBUSY:
397 goto busy;
398 case EACCES:
399 goto no_permission;
400 default:
401 goto open_failed;
402 }
403 }
404
405 return TRUE;
406
407 /* ERRORS */
408 busy:
409 {
410 GST_ELEMENT_ERROR (oss, RESOURCE, BUSY,
411 (_("Could not open audio device for playback. "
412 "Device is being used by another application.")), (NULL));
413 return FALSE;
414 }
415 no_permission:
416 {
417 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
418 (_("Could not open audio device for playback. "
419 "You don't have permission to open the device.")),
420 GST_ERROR_SYSTEM);
421 return FALSE;
422 }
423 open_failed:
424 {
425 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_WRITE,
426 (_("Could not open audio device for playback.")), GST_ERROR_SYSTEM);
427 return FALSE;
428 }
429 }
430
431 static gboolean
gst_oss_sink_close(GstAudioSink * asink)432 gst_oss_sink_close (GstAudioSink * asink)
433 {
434 close (GST_OSSSINK (asink)->fd);
435 GST_OSSSINK (asink)->fd = -1;
436 return TRUE;
437 }
438
439 static gboolean
gst_oss_sink_prepare(GstAudioSink * asink,GstAudioRingBufferSpec * spec)440 gst_oss_sink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec)
441 {
442 GstOssSink *oss;
443 struct audio_buf_info info;
444 int mode;
445 int tmp;
446 guint width, rate, channels;
447
448 oss = GST_OSSSINK (asink);
449
450 /* we opened non-blocking so that we can detect if the device is available
451 * without hanging forever. We now want to remove the non-blocking flag. */
452 mode = fcntl (oss->fd, F_GETFL);
453 mode &= ~O_NONBLOCK;
454 if (fcntl (oss->fd, F_SETFL, mode) == -1) {
455 /* some drivers do no support unsetting the non-blocking flag, try to
456 * close/open the device then. This is racy but we error out properly. */
457 gst_oss_sink_close (asink);
458 if ((oss->fd = open (oss->device, O_WRONLY, 0)) == -1)
459 goto non_block;
460 }
461
462 tmp = gst_oss_sink_get_format (spec->type,
463 GST_AUDIO_INFO_FORMAT (&spec->info));
464 if (tmp == 0)
465 goto wrong_format;
466
467 width = GST_AUDIO_INFO_WIDTH (&spec->info);
468 rate = GST_AUDIO_INFO_RATE (&spec->info);
469 channels = GST_AUDIO_INFO_CHANNELS (&spec->info);
470
471 if (width != 32 && width != 24 && width != 16 && width != 8)
472 goto dodgy_width;
473
474 SET_PARAM (oss, SNDCTL_DSP_SETFMT, tmp, "SETFMT");
475 if (channels == 2)
476 SET_PARAM (oss, SNDCTL_DSP_STEREO, 1, "STEREO");
477 SET_PARAM (oss, SNDCTL_DSP_CHANNELS, channels, "CHANNELS");
478 SET_PARAM (oss, SNDCTL_DSP_SPEED, rate, "SPEED");
479
480 tmp = ilog2 (spec->segsize);
481 tmp = ((spec->segtotal & 0x7fff) << 16) | tmp;
482 GST_DEBUG_OBJECT (oss, "set segsize: %d, segtotal: %d, value: %08x",
483 spec->segsize, spec->segtotal, tmp);
484
485 SET_PARAM (oss, SNDCTL_DSP_SETFRAGMENT, tmp, "SETFRAGMENT");
486 GET_PARAM (oss, SNDCTL_DSP_GETOSPACE, &info, "GETOSPACE");
487
488 spec->segsize = info.fragsize;
489 spec->segtotal = info.fragstotal;
490
491 oss->bytes_per_sample = GST_AUDIO_INFO_BPF (&spec->info);
492
493 GST_DEBUG_OBJECT (oss, "got segsize: %d, segtotal: %d, value: %08x",
494 spec->segsize, spec->segtotal, tmp);
495
496 return TRUE;
497
498 /* ERRORS */
499 non_block:
500 {
501 GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
502 ("Unable to set device %s in non blocking mode: %s",
503 oss->device, g_strerror (errno)));
504 return FALSE;
505 }
506 wrong_format:
507 {
508 GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
509 ("Unable to get format (%d, %d)", spec->type,
510 GST_AUDIO_INFO_FORMAT (&spec->info)));
511 return FALSE;
512 }
513 dodgy_width:
514 {
515 GST_ELEMENT_ERROR (oss, RESOURCE, SETTINGS, (NULL),
516 ("unexpected width %d", width));
517 return FALSE;
518 }
519 }
520
521 static gboolean
gst_oss_sink_unprepare(GstAudioSink * asink)522 gst_oss_sink_unprepare (GstAudioSink * asink)
523 {
524 /* could do a SNDCTL_DSP_RESET, but the OSS manual recommends a close/open */
525
526 if (!gst_oss_sink_close (asink))
527 goto couldnt_close;
528
529 if (!gst_oss_sink_open (asink))
530 goto couldnt_reopen;
531
532 return TRUE;
533
534 /* ERRORS */
535 couldnt_close:
536 {
537 GST_DEBUG_OBJECT (asink, "Could not close the audio device");
538 return FALSE;
539 }
540 couldnt_reopen:
541 {
542 GST_DEBUG_OBJECT (asink, "Could not reopen the audio device");
543 return FALSE;
544 }
545 }
546
547 static gint
gst_oss_sink_write(GstAudioSink * asink,gpointer data,guint length)548 gst_oss_sink_write (GstAudioSink * asink, gpointer data, guint length)
549 {
550 return write (GST_OSSSINK (asink)->fd, data, length);
551 }
552
553 static guint
gst_oss_sink_delay(GstAudioSink * asink)554 gst_oss_sink_delay (GstAudioSink * asink)
555 {
556 GstOssSink *oss;
557 gint delay = 0;
558 gint ret;
559
560 oss = GST_OSSSINK (asink);
561
562 #ifdef SNDCTL_DSP_GETODELAY
563 ret = ioctl (oss->fd, SNDCTL_DSP_GETODELAY, &delay);
564 #else
565 ret = -1;
566 #endif
567 if (ret < 0) {
568 audio_buf_info info;
569
570 ret = ioctl (oss->fd, SNDCTL_DSP_GETOSPACE, &info);
571
572 delay = (ret < 0 ? 0 : (info.fragstotal * info.fragsize) - info.bytes);
573 }
574 return delay / oss->bytes_per_sample;
575 }
576
577 static void
gst_oss_sink_reset(GstAudioSink * asink)578 gst_oss_sink_reset (GstAudioSink * asink)
579 {
580 /* There's nothing we can do here really: OSS can't handle access to the
581 * same device/fd from multiple threads and might deadlock or blow up in
582 * other ways if we try an ioctl SNDCTL_DSP_RESET or similar */
583 }
584