1 /* GStreamer
2 * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3 * 2000,2005 Wim Taymans <wim@fluendo.com>
4 *
5 * gstosssrc.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-osssrc
25 *
26 * This element lets you record sound using the Open Sound System (OSS).
27 *
28 * <refsect2>
29 * <title>Example pipelines</title>
30 * |[
31 * gst-launch-1.0 -v osssrc ! audioconvert ! vorbisenc ! oggmux ! filesink location=mymusic.ogg
32 * ]| will record sound from your sound card using OSS and encode it to an
33 * Ogg/Vorbis file (this will only work if your mixer settings are right
34 * and the right inputs enabled etc.)
35 * </refsect2>
36 */
37
38 #ifdef HAVE_CONFIG_H
39 #include "config.h"
40 #endif
41
42 #include <sys/ioctl.h>
43 #include <fcntl.h>
44 #include <errno.h>
45 #include <unistd.h>
46 #include <string.h>
47
48 #ifdef HAVE_OSS_INCLUDE_IN_SYS
49 # include <sys/soundcard.h>
50 #else
51 # ifdef HAVE_OSS_INCLUDE_IN_ROOT
52 # include <soundcard.h>
53 # else
54 # ifdef HAVE_OSS_INCLUDE_IN_MACHINE
55 # include <machine/soundcard.h>
56 # else
57 # error "What to include?"
58 # endif /* HAVE_OSS_INCLUDE_IN_MACHINE */
59 # endif /* HAVE_OSS_INCLUDE_IN_ROOT */
60 #endif /* HAVE_OSS_INCLUDE_IN_SYS */
61
62 #include "common.h"
63 #include "gstosssrc.h"
64
65 #include <gst/gst-i18n-plugin.h>
66
67 GST_DEBUG_CATEGORY_EXTERN (oss_debug);
68 #define GST_CAT_DEFAULT oss_debug
69
70 #define DEFAULT_DEVICE "/dev/dsp"
71 #define DEFAULT_DEVICE_NAME ""
72
73 enum
74 {
75 PROP_0,
76 PROP_DEVICE,
77 PROP_DEVICE_NAME,
78 };
79
80 #define gst_oss_src_parent_class parent_class
81 G_DEFINE_TYPE (GstOssSrc, gst_oss_src, GST_TYPE_AUDIO_SRC);
82
83 static void gst_oss_src_get_property (GObject * object, guint prop_id,
84 GValue * value, GParamSpec * pspec);
85 static void gst_oss_src_set_property (GObject * object, guint prop_id,
86 const GValue * value, GParamSpec * pspec);
87
88 static void gst_oss_src_dispose (GObject * object);
89 static void gst_oss_src_finalize (GstOssSrc * osssrc);
90
91 static GstCaps *gst_oss_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter);
92
93 static gboolean gst_oss_src_open (GstAudioSrc * asrc);
94 static gboolean gst_oss_src_close (GstAudioSrc * asrc);
95 static gboolean gst_oss_src_prepare (GstAudioSrc * asrc,
96 GstAudioRingBufferSpec * spec);
97 static gboolean gst_oss_src_unprepare (GstAudioSrc * asrc);
98 static guint gst_oss_src_read (GstAudioSrc * asrc, gpointer data, guint length,
99 GstClockTime * timestamp);
100 static guint gst_oss_src_delay (GstAudioSrc * asrc);
101 static void gst_oss_src_reset (GstAudioSrc * asrc);
102
103 #define FORMATS "{" GST_AUDIO_NE(S32)","GST_AUDIO_NE(U32)"," \
104 GST_AUDIO_NE(S24)","GST_AUDIO_NE(U24)"," \
105 GST_AUDIO_NE(S16)","GST_AUDIO_NE(U16)"," \
106 "S8, U8 }"
107
108 static GstStaticPadTemplate osssrc_src_factory = GST_STATIC_PAD_TEMPLATE ("src",
109 GST_PAD_SRC,
110 GST_PAD_ALWAYS,
111 GST_STATIC_CAPS ("audio/x-raw, "
112 "format = (string) " FORMATS ", "
113 "layout = (string) interleaved, "
114 "rate = (int) [ 1, MAX ], "
115 "channels = (int) 1; "
116 "audio/x-raw, "
117 "format = (string) " FORMATS ", "
118 "layout = (string) interleaved, "
119 "rate = (int) [ 1, MAX ], "
120 "channels = (int) 2, " "channel-mask = (bitmask) 0x3")
121 );
122
123 static void
gst_oss_src_dispose(GObject * object)124 gst_oss_src_dispose (GObject * object)
125 {
126 G_OBJECT_CLASS (parent_class)->dispose (object);
127 }
128
129 static void
gst_oss_src_class_init(GstOssSrcClass * klass)130 gst_oss_src_class_init (GstOssSrcClass * klass)
131 {
132 GObjectClass *gobject_class;
133 GstElementClass *gstelement_class;
134 GstBaseSrcClass *gstbasesrc_class;
135 GstAudioSrcClass *gstaudiosrc_class;
136
137 gobject_class = (GObjectClass *) klass;
138 gstelement_class = (GstElementClass *) klass;
139 gstbasesrc_class = (GstBaseSrcClass *) klass;
140 gstaudiosrc_class = (GstAudioSrcClass *) klass;
141
142 gobject_class->dispose = gst_oss_src_dispose;
143 gobject_class->finalize = (GObjectFinalizeFunc) gst_oss_src_finalize;
144 gobject_class->get_property = gst_oss_src_get_property;
145 gobject_class->set_property = gst_oss_src_set_property;
146
147 gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_oss_src_getcaps);
148
149 gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_oss_src_open);
150 gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_oss_src_prepare);
151 gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_oss_src_unprepare);
152 gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_oss_src_close);
153 gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_oss_src_read);
154 gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_oss_src_delay);
155 gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_oss_src_reset);
156
157 g_object_class_install_property (gobject_class, PROP_DEVICE,
158 g_param_spec_string ("device", "Device",
159 "OSS device (usually /dev/dspN)", DEFAULT_DEVICE,
160 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
161
162 g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
163 g_param_spec_string ("device-name", "Device name",
164 "Human-readable name of the sound device", DEFAULT_DEVICE_NAME,
165 G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
166
167
168 gst_element_class_set_static_metadata (gstelement_class, "Audio Source (OSS)",
169 "Source/Audio",
170 "Capture from a sound card via OSS",
171 "Erik Walthinsen <omega@cse.ogi.edu>, " "Wim Taymans <wim@fluendo.com>");
172
173 gst_element_class_add_static_pad_template (gstelement_class,
174 &osssrc_src_factory);
175 }
176
177 static void
gst_oss_src_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)178 gst_oss_src_set_property (GObject * object, guint prop_id,
179 const GValue * value, GParamSpec * pspec)
180 {
181 GstOssSrc *src;
182
183 src = GST_OSS_SRC (object);
184
185 switch (prop_id) {
186 case PROP_DEVICE:
187 g_free (src->device);
188 src->device = g_value_dup_string (value);
189 break;
190 default:
191 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
192 break;
193 }
194 }
195
196 static void
gst_oss_src_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)197 gst_oss_src_get_property (GObject * object, guint prop_id,
198 GValue * value, GParamSpec * pspec)
199 {
200 GstOssSrc *src;
201
202 src = GST_OSS_SRC (object);
203
204 switch (prop_id) {
205 case PROP_DEVICE:
206 g_value_set_string (value, src->device);
207 break;
208 case PROP_DEVICE_NAME:
209 g_value_set_string (value, src->device_name);
210 break;
211 default:
212 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
213 break;
214 }
215 }
216
217 static void
gst_oss_src_init(GstOssSrc * osssrc)218 gst_oss_src_init (GstOssSrc * osssrc)
219 {
220 const gchar *device;
221
222 GST_DEBUG ("initializing osssrc");
223
224 device = g_getenv ("AUDIODEV");
225 if (device == NULL)
226 device = DEFAULT_DEVICE;
227
228 osssrc->fd = -1;
229 osssrc->device = g_strdup (device);
230 osssrc->device_name = g_strdup (DEFAULT_DEVICE_NAME);
231 osssrc->probed_caps = NULL;
232 }
233
234 static void
gst_oss_src_finalize(GstOssSrc * osssrc)235 gst_oss_src_finalize (GstOssSrc * osssrc)
236 {
237 g_free (osssrc->device);
238 g_free (osssrc->device_name);
239
240 G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (osssrc));
241 }
242
243 static GstCaps *
gst_oss_src_getcaps(GstBaseSrc * bsrc,GstCaps * filter)244 gst_oss_src_getcaps (GstBaseSrc * bsrc, GstCaps * filter)
245 {
246 GstOssSrc *osssrc;
247 GstCaps *caps;
248
249 osssrc = GST_OSS_SRC (bsrc);
250
251 if (osssrc->fd == -1) {
252 GST_DEBUG_OBJECT (osssrc, "device not open, using template caps");
253 return NULL; /* base class will get template caps for us */
254 }
255
256 if (osssrc->probed_caps) {
257 GST_LOG_OBJECT (osssrc, "Returning cached caps");
258 return gst_caps_ref (osssrc->probed_caps);
259 }
260
261 caps = gst_oss_helper_probe_caps (osssrc->fd);
262
263 if (caps) {
264 osssrc->probed_caps = gst_caps_ref (caps);
265 }
266
267 GST_INFO_OBJECT (osssrc, "returning caps %" GST_PTR_FORMAT, caps);
268
269 if (filter && caps) {
270 GstCaps *intersection;
271
272 intersection =
273 gst_caps_intersect_full (filter, caps, GST_CAPS_INTERSECT_FIRST);
274 gst_caps_unref (caps);
275 return intersection;
276 } else {
277 return caps;
278 }
279 }
280
281 static gint
ilog2(gint x)282 ilog2 (gint x)
283 {
284 /* well... hacker's delight explains... */
285 x = x | (x >> 1);
286 x = x | (x >> 2);
287 x = x | (x >> 4);
288 x = x | (x >> 8);
289 x = x | (x >> 16);
290 x = x - ((x >> 1) & 0x55555555);
291 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
292 x = (x + (x >> 4)) & 0x0f0f0f0f;
293 x = x + (x >> 8);
294 x = x + (x >> 16);
295 return (x & 0x0000003f) - 1;
296 }
297
298 static gint
gst_oss_src_get_format(GstAudioRingBufferFormatType fmt,GstAudioFormat rfmt)299 gst_oss_src_get_format (GstAudioRingBufferFormatType fmt, GstAudioFormat rfmt)
300 {
301 gint result;
302
303 switch (fmt) {
304 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MU_LAW:
305 result = AFMT_MU_LAW;
306 break;
307 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_A_LAW:
308 result = AFMT_A_LAW;
309 break;
310 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_IMA_ADPCM:
311 result = AFMT_IMA_ADPCM;
312 break;
313 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_MPEG:
314 result = AFMT_MPEG;
315 break;
316 case GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW:
317 {
318 switch (rfmt) {
319 case GST_AUDIO_FORMAT_S8:
320 result = AFMT_S8;
321 break;
322 case GST_AUDIO_FORMAT_U8:
323 result = AFMT_U8;
324 break;
325 case GST_AUDIO_FORMAT_S16LE:
326 result = AFMT_S16_LE;
327 break;
328 case GST_AUDIO_FORMAT_S16BE:
329 result = AFMT_S16_BE;
330 break;
331 case GST_AUDIO_FORMAT_U16LE:
332 result = AFMT_U16_LE;
333 break;
334 case GST_AUDIO_FORMAT_U16BE:
335 result = AFMT_U16_BE;
336 break;
337 case GST_AUDIO_FORMAT_S24LE:
338 result = AFMT_S24_LE;
339 break;
340 case GST_AUDIO_FORMAT_S24BE:
341 result = AFMT_S24_BE;
342 break;
343 case GST_AUDIO_FORMAT_U24LE:
344 result = AFMT_U24_LE;
345 break;
346 case GST_AUDIO_FORMAT_U24BE:
347 result = AFMT_U24_BE;
348 break;
349 case GST_AUDIO_FORMAT_S32LE:
350 result = AFMT_S32_LE;
351 break;
352 case GST_AUDIO_FORMAT_S32BE:
353 result = AFMT_S32_BE;
354 break;
355 case GST_AUDIO_FORMAT_U32LE:
356 result = AFMT_U32_LE;
357 break;
358 case GST_AUDIO_FORMAT_U32BE:
359 result = AFMT_U32_BE;
360 break;
361 default:
362 result = 0;
363 break;
364 }
365 break;
366 }
367 default:
368 result = 0;
369 break;
370 }
371 return result;
372 }
373
374 static gboolean
gst_oss_src_open(GstAudioSrc * asrc)375 gst_oss_src_open (GstAudioSrc * asrc)
376 {
377 GstOssSrc *oss;
378 int mode;
379
380 oss = GST_OSS_SRC (asrc);
381
382 mode = O_RDONLY;
383 mode |= O_NONBLOCK;
384
385 oss->fd = open (oss->device, mode, 0);
386 if (oss->fd == -1) {
387 switch (errno) {
388 case EACCES:
389 goto no_permission;
390 default:
391 goto open_failed;
392 }
393 }
394
395 g_free (oss->device_name);
396 oss->device_name = gst_oss_helper_get_card_name ("/dev/mixer");
397
398 return TRUE;
399
400 no_permission:
401 {
402 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
403 (_("Could not open audio device for recording. "
404 "You don't have permission to open the device.")),
405 GST_ERROR_SYSTEM);
406 return FALSE;
407 }
408 open_failed:
409 {
410 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
411 (_("Could not open audio device for recording.")),
412 ("Unable to open device %s for recording: %s",
413 oss->device, g_strerror (errno)));
414 return FALSE;
415 }
416 }
417
418 static gboolean
gst_oss_src_close(GstAudioSrc * asrc)419 gst_oss_src_close (GstAudioSrc * asrc)
420 {
421 GstOssSrc *oss;
422
423 oss = GST_OSS_SRC (asrc);
424
425 close (oss->fd);
426
427 gst_caps_replace (&oss->probed_caps, NULL);
428
429 return TRUE;
430 }
431
432 static gboolean
gst_oss_src_prepare(GstAudioSrc * asrc,GstAudioRingBufferSpec * spec)433 gst_oss_src_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec)
434 {
435 GstOssSrc *oss;
436 struct audio_buf_info info;
437 int mode;
438 int fmt, tmp;
439 guint width, rate, channels;
440
441 oss = GST_OSS_SRC (asrc);
442
443 mode = fcntl (oss->fd, F_GETFL);
444 mode &= ~O_NONBLOCK;
445 if (fcntl (oss->fd, F_SETFL, mode) == -1)
446 goto non_block;
447
448 fmt = gst_oss_src_get_format (spec->type,
449 GST_AUDIO_INFO_FORMAT (&spec->info));
450 if (fmt == 0)
451 goto wrong_format;
452
453 width = GST_AUDIO_INFO_WIDTH (&spec->info);
454 rate = GST_AUDIO_INFO_RATE (&spec->info);
455 channels = GST_AUDIO_INFO_CHANNELS (&spec->info);
456
457 if (width != 32 && width != 24 && width != 16 && width != 8)
458 goto dodgy_width;
459
460 tmp = ilog2 (spec->segsize);
461 tmp = ((spec->segtotal & 0x7fff) << 16) | tmp;
462 GST_DEBUG_OBJECT (oss, "set segsize: %d, segtotal: %d, value: %08x",
463 spec->segsize, spec->segtotal, tmp);
464
465 SET_PARAM (oss, SNDCTL_DSP_SETFRAGMENT, tmp, "SETFRAGMENT");
466
467 SET_PARAM (oss, SNDCTL_DSP_RESET, 0, "RESET");
468
469 SET_PARAM (oss, SNDCTL_DSP_SETFMT, fmt, "SETFMT");
470 if (channels == 2)
471 SET_PARAM (oss, SNDCTL_DSP_STEREO, 1, "STEREO");
472 SET_PARAM (oss, SNDCTL_DSP_CHANNELS, channels, "CHANNELS");
473 SET_PARAM (oss, SNDCTL_DSP_SPEED, rate, "SPEED");
474
475 GET_PARAM (oss, SNDCTL_DSP_GETISPACE, &info, "GETISPACE");
476
477 spec->segsize = info.fragsize;
478 spec->segtotal = info.fragstotal;
479
480 oss->bytes_per_sample = GST_AUDIO_INFO_BPF (&spec->info);
481
482 GST_DEBUG_OBJECT (oss, "got segsize: %d, segtotal: %d, value: %08x",
483 spec->segsize, spec->segtotal, tmp);
484
485 return TRUE;
486
487 non_block:
488 {
489 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
490 ("Unable to set device %s in non blocking mode: %s",
491 oss->device, g_strerror (errno)), (NULL));
492 return FALSE;
493 }
494 wrong_format:
495 {
496 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
497 ("Unable to get format (%d, %d)", spec->type,
498 GST_AUDIO_INFO_FORMAT (&spec->info)), (NULL));
499 return FALSE;
500 }
501 dodgy_width:
502 {
503 GST_ELEMENT_ERROR (oss, RESOURCE, OPEN_READ,
504 ("Unexpected width %d", width), (NULL));
505 return FALSE;
506 }
507 }
508
509 static gboolean
gst_oss_src_unprepare(GstAudioSrc * asrc)510 gst_oss_src_unprepare (GstAudioSrc * asrc)
511 {
512 /* could do a SNDCTL_DSP_RESET, but the OSS manual recommends a close/open */
513
514 if (!gst_oss_src_close (asrc))
515 goto couldnt_close;
516
517 if (!gst_oss_src_open (asrc))
518 goto couldnt_reopen;
519
520 return TRUE;
521
522 couldnt_close:
523 {
524 GST_DEBUG_OBJECT (asrc, "Could not close the audio device");
525 return FALSE;
526 }
527 couldnt_reopen:
528 {
529 GST_DEBUG_OBJECT (asrc, "Could not reopen the audio device");
530 return FALSE;
531 }
532 }
533
534 static guint
gst_oss_src_read(GstAudioSrc * asrc,gpointer data,guint length,GstClockTime * timestamp)535 gst_oss_src_read (GstAudioSrc * asrc, gpointer data, guint length,
536 GstClockTime * timestamp)
537 {
538 return read (GST_OSS_SRC (asrc)->fd, data, length);
539 }
540
541 static guint
gst_oss_src_delay(GstAudioSrc * asrc)542 gst_oss_src_delay (GstAudioSrc * asrc)
543 {
544 GstOssSrc *oss;
545 gint delay = 0;
546 gint ret;
547
548 oss = GST_OSS_SRC (asrc);
549
550 #ifdef SNDCTL_DSP_GETODELAY
551 ret = ioctl (oss->fd, SNDCTL_DSP_GETODELAY, &delay);
552 #else
553 ret = -1;
554 #endif
555 if (ret < 0) {
556 audio_buf_info info;
557
558 ret = ioctl (oss->fd, SNDCTL_DSP_GETOSPACE, &info);
559
560 delay = (ret < 0 ? 0 : (info.fragstotal * info.fragsize) - info.bytes);
561 }
562 return delay / oss->bytes_per_sample;
563 }
564
565 static void
gst_oss_src_reset(GstAudioSrc * asrc)566 gst_oss_src_reset (GstAudioSrc * asrc)
567 {
568 /* There's nothing we can do here really: OSS can't handle access to the
569 * same device/fd from multiple threads and might deadlock or blow up in
570 * other ways if we try an ioctl SNDCTL_DSP_RESET or similar */
571 }
572