diff options
| author | Vineet Kumar <git@vineetk.net> | 2026-06-15 14:54:51 -0400 |
|---|---|---|
| committer | Vineet Kumar <git@vineetk.net> | 2026-06-15 14:54:51 -0400 |
| commit | e81f04fa53e7e01afdc834d9c22b5c982c98f59b (patch) | |
| tree | 763d6d68516ca9d184ddd2402978adcc4027a99d /multimedia/gstreamer1/plugins-base/files | |
| parent | 92e45e47c29ec037842c4a34ebc0c14143d413ff (diff) | |
This is due to the following two reasons:
1. it's very out of date compared with current ports tree (like by 2+
years!)
- some of the ports here were mainly just updates I didn't upstream,
which have since now been part of openbsd, like verilator
2. removing dependencies is a lot of headache to stay in sync and/or for
ports I no longer use
- e.g. dbus is very difficult to remove in a desktop while patching
to remove from gtk and downstream
- I don't want to spend more time reducing number of dependencies
when I can be working instead. I no longer have as much free time
as I did in high school :(
Diffstat (limited to 'multimedia/gstreamer1/plugins-base/files')
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/CVS/Entries | 8 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/CVS/Repository | 1 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/gstsndio.c | 403 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/gstsndio.h | 79 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/meson.build | 19 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/sndiosink.c | 226 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/sndiosink.h | 57 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/sndiosrc.c | 228 | ||||
| -rw-r--r-- | multimedia/gstreamer1/plugins-base/files/sndiosrc.h | 57 |
9 files changed, 0 insertions, 1078 deletions
diff --git a/multimedia/gstreamer1/plugins-base/files/CVS/Entries b/multimedia/gstreamer1/plugins-base/files/CVS/Entries deleted file mode 100644 index 07cbfbd..0000000 --- a/multimedia/gstreamer1/plugins-base/files/CVS/Entries +++ /dev/null | |||
| @@ -1,8 +0,0 @@ | |||
| 1 | /sndiosink.h/1.1/Sat Sep 22 07:34:44 2012// | ||
| 2 | /sndiosrc.h/1.1/Sat Sep 22 07:34:44 2012// | ||
| 3 | /sndiosink.c/1.2/Mon Nov 3 08:38:19 2014// | ||
| 4 | /gstsndio.c/1.4/Sun Apr 21 17:16:00 2019// | ||
| 5 | /gstsndio.h/1.3/Sun Apr 21 17:16:00 2019// | ||
| 6 | /sndiosrc.c/1.3/Sun Apr 21 17:16:00 2019// | ||
| 7 | /meson.build/1.3/Wed Jan 25 18:20:48 2023// | ||
| 8 | D | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/CVS/Repository b/multimedia/gstreamer1/plugins-base/files/CVS/Repository deleted file mode 100644 index 1acee91..0000000 --- a/multimedia/gstreamer1/plugins-base/files/CVS/Repository +++ /dev/null | |||
| @@ -1 +0,0 @@ | |||
| 1 | ports/multimedia/gstreamer1/plugins-base/files | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/gstsndio.c b/multimedia/gstreamer1/plugins-base/files/gstsndio.c deleted file mode 100644 index 45644db..0000000 --- a/multimedia/gstreamer1/plugins-base/files/gstsndio.c +++ /dev/null | |||
| @@ -1,403 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2008 Jacob Meuser <jakemsr@sdf.lonestar.org> | ||
| 3 | * Copyright (C) 2012 Alexandre Ratchov <alex@caoua.org> | ||
| 4 | * | ||
| 5 | * Permission to use, copy, modify, and distribute this software for any | ||
| 6 | * purpose with or without fee is hereby granted, provided that the above | ||
| 7 | * copyright notice and this permission notice appear in all copies. | ||
| 8 | * | ||
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
| 12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
| 14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
| 15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
| 16 | */ | ||
| 17 | |||
| 18 | #ifdef HAVE_CONFIG_H | ||
| 19 | #include "config.h" | ||
| 20 | #endif | ||
| 21 | |||
| 22 | #include <stdio.h> | ||
| 23 | #include "gstsndio.h" | ||
| 24 | |||
| 25 | GST_DEBUG_CATEGORY (gst_sndio_debug); | ||
| 26 | #define GST_CAT_DEFAULT gst_sndio_debug | ||
| 27 | |||
| 28 | GType gst_sndiosink_get_type (void); | ||
| 29 | GType gst_sndiosrc_get_type (void); | ||
| 30 | |||
| 31 | static gboolean | ||
| 32 | plugin_init (GstPlugin * plugin) | ||
| 33 | { | ||
| 34 | GST_DEBUG_CATEGORY_INIT (gst_sndio_debug, "sndio", 0, "sndio plugins"); | ||
| 35 | |||
| 36 | /* prefer sndiosrc over pulsesrc (GST_RANK_PRIMARY + 10) */ | ||
| 37 | if (!gst_element_register (plugin, "sndiosrc", GST_RANK_PRIMARY + 20, | ||
| 38 | gst_sndiosrc_get_type())) | ||
| 39 | return FALSE; | ||
| 40 | /* prefer sndiosink over pulsesink (GST_RANK_PRIMARY + 10) */ | ||
| 41 | if (!gst_element_register (plugin, "sndiosink", GST_RANK_PRIMARY + 20, | ||
| 42 | gst_sndiosink_get_type())) | ||
| 43 | return FALSE; | ||
| 44 | return TRUE; | ||
| 45 | } | ||
| 46 | |||
| 47 | GST_PLUGIN_DEFINE (GST_VERSION_MAJOR, | ||
| 48 | GST_VERSION_MINOR, | ||
| 49 | sndio, | ||
| 50 | "sndio plugin library", | ||
| 51 | plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN) | ||
| 52 | |||
| 53 | /* | ||
| 54 | * common code to src and sink | ||
| 55 | */ | ||
| 56 | |||
| 57 | void | ||
| 58 | gst_sndio_init (struct gstsndio *sio, GObject *obj) | ||
| 59 | { | ||
| 60 | sio->obj = obj; | ||
| 61 | sio->hdl = NULL; | ||
| 62 | sio->device = g_strdup (SIO_DEVANY); | ||
| 63 | /* XXX not implemented; only used for src, not sink */ | ||
| 64 | // sio->driver_timestamps = FALSE; | ||
| 65 | } | ||
| 66 | |||
| 67 | void | ||
| 68 | gst_sndio_finalize (struct gstsndio *sio) | ||
| 69 | { | ||
| 70 | gst_caps_replace (&sio->cur_caps, NULL); | ||
| 71 | g_free (sio->device); | ||
| 72 | } | ||
| 73 | |||
| 74 | GstCaps * | ||
| 75 | gst_sndio_getcaps (struct gstsndio *sio, GstCaps * filter) | ||
| 76 | { | ||
| 77 | if (sio->cur_caps == NULL) { | ||
| 78 | /* XXX */ | ||
| 79 | GST_LOG_OBJECT (sio->obj, "getcaps called, returning template caps"); | ||
| 80 | return NULL; | ||
| 81 | } | ||
| 82 | |||
| 83 | GST_LOG_OBJECT (sio->obj, "returning %" GST_PTR_FORMAT, sio->cur_caps); | ||
| 84 | |||
| 85 | if (filter) { | ||
| 86 | return gst_caps_intersect_full (filter, | ||
| 87 | sio->cur_caps, GST_CAPS_INTERSECT_FIRST); | ||
| 88 | } else { | ||
| 89 | return gst_caps_ref (sio->cur_caps); | ||
| 90 | } | ||
| 91 | } | ||
| 92 | |||
| 93 | static void | ||
| 94 | gst_sndio_onvol (void *arg, unsigned int vol) | ||
| 95 | { | ||
| 96 | struct gstsndio *sio = arg; | ||
| 97 | sio->volume = vol; | ||
| 98 | g_object_notify (G_OBJECT (sio->obj), "mute"); | ||
| 99 | g_object_notify (G_OBJECT (sio->obj), "volume"); | ||
| 100 | } | ||
| 101 | |||
| 102 | gboolean | ||
| 103 | gst_sndio_open (struct gstsndio *sio, gint mode) | ||
| 104 | { | ||
| 105 | GValue list = G_VALUE_INIT, item = G_VALUE_INIT; | ||
| 106 | GstStructure *s; | ||
| 107 | GstCaps *caps; | ||
| 108 | struct sio_enc *enc; | ||
| 109 | struct sio_cap cap; | ||
| 110 | char fmt[16]; | ||
| 111 | int i, chan; | ||
| 112 | |||
| 113 | GST_DEBUG_OBJECT (sio->obj, "open"); | ||
| 114 | |||
| 115 | sio->hdl = sio_open (sio->device, mode, 0); | ||
| 116 | if (sio->hdl == NULL) { | ||
| 117 | GST_ELEMENT_ERROR (sio->obj, RESOURCE, OPEN_READ_WRITE, | ||
| 118 | ("Couldn't open sndio device"), (NULL)); | ||
| 119 | return FALSE; | ||
| 120 | } | ||
| 121 | sio->mode = mode; | ||
| 122 | |||
| 123 | if (!sio_getcap(sio->hdl, &cap)) { | ||
| 124 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_WRITE, | ||
| 125 | ("Couldn't get device capabilities"), (NULL)); | ||
| 126 | sio_close(sio->hdl); | ||
| 127 | sio->hdl = NULL; | ||
| 128 | return FALSE; | ||
| 129 | } | ||
| 130 | if (cap.nconf == 0) { | ||
| 131 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_WRITE, | ||
| 132 | ("Device has empty capabilities"), (NULL)); | ||
| 133 | sio_close(sio->hdl); | ||
| 134 | sio->hdl = NULL; | ||
| 135 | return FALSE; | ||
| 136 | } | ||
| 137 | sio_onvol (sio->hdl, gst_sndio_onvol, sio); | ||
| 138 | |||
| 139 | caps = gst_caps_new_empty (); | ||
| 140 | s = gst_structure_new ("audio/x-raw", (char *)NULL, (void *)NULL); | ||
| 141 | |||
| 142 | /* | ||
| 143 | * scan supported rates | ||
| 144 | */ | ||
| 145 | g_value_init (&list, GST_TYPE_LIST); | ||
| 146 | g_value_init (&item, G_TYPE_INT); | ||
| 147 | for (i = 0; i < SIO_NRATE; i++) { | ||
| 148 | if ((cap.confs[0].rate & (1 << i)) == 0) | ||
| 149 | continue; | ||
| 150 | g_value_set_int(&item, cap.rate[i]); | ||
| 151 | gst_value_list_append_value (&list, &item); | ||
| 152 | } | ||
| 153 | gst_structure_set_value (s, "rate", &list); | ||
| 154 | g_value_unset (&item); | ||
| 155 | g_value_unset (&list); | ||
| 156 | |||
| 157 | /* | ||
| 158 | * scan supported channels | ||
| 159 | */ | ||
| 160 | g_value_init (&list, GST_TYPE_LIST); | ||
| 161 | g_value_init (&item, G_TYPE_INT); | ||
| 162 | chan = (mode == SIO_PLAY) ? cap.confs[0].pchan : cap.confs[0].rchan; | ||
| 163 | for (i = 0; i < SIO_NCHAN; i++) { | ||
| 164 | if ((chan & (1 << i)) == 0) | ||
| 165 | continue; | ||
| 166 | g_value_set_int(&item, (mode == SIO_PLAY) ? cap.pchan[i] : cap.rchan[i]); | ||
| 167 | gst_value_list_append_value (&list, &item); | ||
| 168 | } | ||
| 169 | gst_structure_set_value (s, "channels", &list); | ||
| 170 | g_value_unset (&item); | ||
| 171 | g_value_unset (&list); | ||
| 172 | |||
| 173 | /* | ||
| 174 | * scan supported encodings | ||
| 175 | */ | ||
| 176 | g_value_init (&list, GST_TYPE_LIST); | ||
| 177 | g_value_init (&item, G_TYPE_STRING); | ||
| 178 | for (i = 0; i < SIO_NENC; i++) { | ||
| 179 | if ((cap.confs[0].enc & (1 << i)) == 0) | ||
| 180 | continue; | ||
| 181 | enc = cap.enc + i; | ||
| 182 | if (enc->bits % 8 != 0) | ||
| 183 | continue; | ||
| 184 | if (enc->bits < enc->bps * 8 && enc->msb) | ||
| 185 | continue; | ||
| 186 | if (enc->bits == enc->bps * 8) { | ||
| 187 | snprintf(fmt, sizeof(fmt), "%s%u%s", | ||
| 188 | enc->sig ? "S" : "U", | ||
| 189 | enc->bits, | ||
| 190 | enc->bps > 1 ? (enc->le ? "LE" : "BE") : ""); | ||
| 191 | } else { | ||
| 192 | snprintf(fmt, sizeof(fmt), "%s%u_%u%s", | ||
| 193 | enc->sig ? "S" : "U", | ||
| 194 | enc->bits, | ||
| 195 | enc->bps * 8, | ||
| 196 | enc->bps > 1 ? (enc->le ? "LE" : "BE") : ""); | ||
| 197 | } | ||
| 198 | g_value_set_string(&item, fmt); | ||
| 199 | gst_value_list_append_value (&list, &item); | ||
| 200 | } | ||
| 201 | gst_structure_set_value (s, "format", &list); | ||
| 202 | g_value_unset (&item); | ||
| 203 | g_value_unset (&list); | ||
| 204 | |||
| 205 | /* | ||
| 206 | * add the only supported layout: interleaved | ||
| 207 | */ | ||
| 208 | g_value_init (&item, G_TYPE_STRING); | ||
| 209 | g_value_set_string(&item, "interleaved"); | ||
| 210 | gst_structure_set_value (s, "layout", &item); | ||
| 211 | g_value_unset (&item); | ||
| 212 | |||
| 213 | gst_caps_append_structure (caps, s); | ||
| 214 | sio->cur_caps = caps; | ||
| 215 | GST_DEBUG ("caps are %s", gst_caps_to_string(caps)); | ||
| 216 | return TRUE; | ||
| 217 | } | ||
| 218 | |||
| 219 | gboolean | ||
| 220 | gst_sndio_close (struct gstsndio *sio) | ||
| 221 | { | ||
| 222 | GST_DEBUG_OBJECT (sio->obj, "close"); | ||
| 223 | |||
| 224 | gst_caps_replace (&sio->cur_caps, NULL); | ||
| 225 | sio_close (sio->hdl); | ||
| 226 | sio->hdl = NULL; | ||
| 227 | return TRUE; | ||
| 228 | } | ||
| 229 | |||
| 230 | static void | ||
| 231 | gst_sndio_cb (void *addr, int delta) | ||
| 232 | { | ||
| 233 | struct gstsndio *sio = addr; | ||
| 234 | |||
| 235 | delta *= sio->bpf; | ||
| 236 | if (sio->mode == SIO_PLAY) | ||
| 237 | sio->delay -= delta; | ||
| 238 | else | ||
| 239 | sio->delay += delta; | ||
| 240 | } | ||
| 241 | |||
| 242 | gboolean | ||
| 243 | gst_sndio_prepare (struct gstsndio *sio, GstAudioRingBufferSpec *spec) | ||
| 244 | { | ||
| 245 | struct sio_par par, retpar; | ||
| 246 | unsigned nchannels; | ||
| 247 | |||
| 248 | GST_DEBUG_OBJECT (sio, "prepare"); | ||
| 249 | |||
| 250 | if (spec->type != GST_AUDIO_RING_BUFFER_FORMAT_TYPE_RAW) { | ||
| 251 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_READ_WRITE, | ||
| 252 | ("Only raw buffer format supported by sndio"), (NULL)); | ||
| 253 | return FALSE; | ||
| 254 | } | ||
| 255 | if (!GST_AUDIO_INFO_IS_INTEGER(&spec->info)) { | ||
| 256 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_READ_WRITE, | ||
| 257 | ("Only integer format supported"), (NULL)); | ||
| 258 | return FALSE; | ||
| 259 | } | ||
| 260 | if (GST_AUDIO_INFO_DEPTH(&spec->info) % 8) { | ||
| 261 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_READ_WRITE, | ||
| 262 | ("Only depths multiple of 8 are supported"), (NULL)); | ||
| 263 | return FALSE; | ||
| 264 | } | ||
| 265 | |||
| 266 | sio_initpar (&par); | ||
| 267 | switch (GST_AUDIO_INFO_FORMAT (&spec->info)) { | ||
| 268 | case GST_AUDIO_FORMAT_S8: | ||
| 269 | case GST_AUDIO_FORMAT_U8: | ||
| 270 | case GST_AUDIO_FORMAT_S16LE: | ||
| 271 | case GST_AUDIO_FORMAT_S16BE: | ||
| 272 | case GST_AUDIO_FORMAT_U16LE: | ||
| 273 | case GST_AUDIO_FORMAT_U16BE: | ||
| 274 | case GST_AUDIO_FORMAT_S32LE: | ||
| 275 | case GST_AUDIO_FORMAT_S32BE: | ||
| 276 | case GST_AUDIO_FORMAT_U32LE: | ||
| 277 | case GST_AUDIO_FORMAT_U32BE: | ||
| 278 | case GST_AUDIO_FORMAT_S24_32LE: | ||
| 279 | case GST_AUDIO_FORMAT_S24_32BE: | ||
| 280 | case GST_AUDIO_FORMAT_U24_32LE: | ||
| 281 | case GST_AUDIO_FORMAT_U24_32BE: | ||
| 282 | case GST_AUDIO_FORMAT_S24LE: | ||
| 283 | case GST_AUDIO_FORMAT_S24BE: | ||
| 284 | case GST_AUDIO_FORMAT_U24LE: | ||
| 285 | case GST_AUDIO_FORMAT_U24BE: | ||
| 286 | break; | ||
| 287 | default: | ||
| 288 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_READ_WRITE, | ||
| 289 | ("Unsupported audio format"), | ||
| 290 | ("format = %d", GST_AUDIO_INFO_FORMAT (&spec->info))); | ||
| 291 | return FALSE; | ||
| 292 | } | ||
| 293 | par.sig = GST_AUDIO_INFO_IS_SIGNED(&spec->info); | ||
| 294 | par.bits = GST_AUDIO_INFO_WIDTH(&spec->info); | ||
| 295 | par.bps = GST_AUDIO_INFO_DEPTH(&spec->info) / 8; | ||
| 296 | if (par.bps > 1) | ||
| 297 | par.le = GST_AUDIO_INFO_IS_LITTLE_ENDIAN(&spec->info); | ||
| 298 | if (par.bits < par.bps * 8) | ||
| 299 | par.msb = 0; | ||
| 300 | par.rate = GST_AUDIO_INFO_RATE(&spec->info); | ||
| 301 | if (sio->mode == SIO_PLAY) | ||
| 302 | par.pchan = GST_AUDIO_INFO_CHANNELS(&spec->info); | ||
| 303 | else | ||
| 304 | par.rchan = GST_AUDIO_INFO_CHANNELS(&spec->info); | ||
| 305 | par.round = par.rate / 1000000. * spec->latency_time; | ||
| 306 | par.appbufsz = par.rate / 1000000. * spec->buffer_time; | ||
| 307 | |||
| 308 | if (!sio_setpar (sio->hdl, &par)) { | ||
| 309 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_WRITE, | ||
| 310 | ("Unsupported audio encoding"), (NULL)); | ||
| 311 | return FALSE; | ||
| 312 | } | ||
| 313 | if (!sio_getpar (sio->hdl, &retpar)) { | ||
| 314 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_WRITE, | ||
| 315 | ("Couldn't get audio device parameters"), (NULL)); | ||
| 316 | return FALSE; | ||
| 317 | } | ||
| 318 | #if 0 | ||
| 319 | GST_DEBUG ("format = %s, " | ||
| 320 | "requested: sig = %d, bits = %d, bps = %d, le = %d, msb = %d, " | ||
| 321 | "rate = %d, pchan = %d, round = %d, appbufsz = %d; " | ||
| 322 | "returned: sig = %d, bits = %d, bps = %d, le = %d, msb = %d, " | ||
| 323 | "rate = %d, pchan = %d, round = %d, appbufsz = %d, bufsz = %d", | ||
| 324 | GST_AUDIO_INFO_NAME(&spec->info), | ||
| 325 | par.sig, par.bits, par.bps, par.le, par.msb, | ||
| 326 | par.rate, par.pchan, par.round, par.appbufsz, | ||
| 327 | retpar.sig, retpar.bits, retpar.bps, retpar.le, retpar.msb, | ||
| 328 | retpar.rate, retpar.pchan, retpar.round, retpar.appbufsz, retpar.bufsz); | ||
| 329 | #endif | ||
| 330 | if (par.bits != retpar.bits || | ||
| 331 | par.bps != retpar.bps || | ||
| 332 | par.rate != retpar.rate || | ||
| 333 | (sio->mode == SIO_PLAY && par.pchan != retpar.pchan) || | ||
| 334 | (sio->mode == SIO_REC && par.rchan != retpar.rchan) || | ||
| 335 | (par.bps > 1 && par.le != retpar.le) || | ||
| 336 | (par.bits < par.bps * 8 && par.msb != retpar.msb)) { | ||
| 337 | GST_ELEMENT_ERROR (sio, RESOURCE, OPEN_WRITE, | ||
| 338 | ("Audio device refused requested parameters"), (NULL)); | ||
| 339 | return FALSE; | ||
| 340 | } | ||
| 341 | |||
| 342 | nchannels = (sio->mode == SIO_PLAY) ? retpar.pchan : retpar.rchan; | ||
| 343 | spec->segsize = retpar.round * retpar.bps * nchannels; | ||
| 344 | spec->segtotal = retpar.bufsz / retpar.round; | ||
| 345 | sio->bpf = retpar.bps * nchannels; | ||
| 346 | sio->delay = 0; | ||
| 347 | sio_onmove (sio->hdl, gst_sndio_cb, sio); | ||
| 348 | |||
| 349 | if (!sio_start (sio->hdl)) { | ||
| 350 | GST_ELEMENT_ERROR (sio->obj, RESOURCE, OPEN_READ_WRITE, | ||
| 351 | ("Could not start sndio"), (NULL)); | ||
| 352 | return FALSE; | ||
| 353 | } | ||
| 354 | return TRUE; | ||
| 355 | } | ||
| 356 | |||
| 357 | gboolean | ||
| 358 | gst_sndio_unprepare (struct gstsndio *sio) | ||
| 359 | { | ||
| 360 | if (sio->hdl) | ||
| 361 | sio_stop (sio->hdl); | ||
| 362 | return TRUE; | ||
| 363 | } | ||
| 364 | |||
| 365 | void | ||
| 366 | gst_sndio_set_property (struct gstsndio *sio, guint prop_id, | ||
| 367 | const GValue * value, GParamSpec * pspec) | ||
| 368 | { | ||
| 369 | switch (prop_id) { | ||
| 370 | case PROP_DEVICE: | ||
| 371 | g_free (sio->device); | ||
| 372 | sio->device = g_value_dup_string (value); | ||
| 373 | break; | ||
| 374 | case PROP_VOLUME: | ||
| 375 | sio_setvol (sio->hdl, g_value_get_double (value) * SIO_MAXVOL); | ||
| 376 | break; | ||
| 377 | case PROP_MUTE: | ||
| 378 | if (g_value_get_boolean (value)) | ||
| 379 | sio_setvol (sio->hdl, 0); | ||
| 380 | break; | ||
| 381 | default: | ||
| 382 | break; | ||
| 383 | } | ||
| 384 | } | ||
| 385 | |||
| 386 | void | ||
| 387 | gst_sndio_get_property (struct gstsndio *sio, guint prop_id, | ||
| 388 | GValue * value, GParamSpec * pspec) | ||
| 389 | { | ||
| 390 | switch (prop_id) { | ||
| 391 | case PROP_DEVICE: | ||
| 392 | g_value_set_string (value, sio->device); | ||
| 393 | break; | ||
| 394 | case PROP_VOLUME: | ||
| 395 | g_value_set_double (value, (gdouble)sio->volume / SIO_MAXVOL); | ||
| 396 | break; | ||
| 397 | case PROP_MUTE: | ||
| 398 | g_value_set_boolean (value, (sio->volume == 0)); | ||
| 399 | break; | ||
| 400 | default: | ||
| 401 | G_OBJECT_WARN_INVALID_PROPERTY_ID (sio->obj, prop_id, pspec); | ||
| 402 | } | ||
| 403 | } | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/gstsndio.h b/multimedia/gstreamer1/plugins-base/files/gstsndio.h deleted file mode 100644 index 1d54126..0000000 --- a/multimedia/gstreamer1/plugins-base/files/gstsndio.h +++ /dev/null | |||
| @@ -1,79 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2012 Alexandre Ratchov <alex@caoua.org> | ||
| 3 | * | ||
| 4 | * Permission to use, copy, modify, and distribute this software for any | ||
| 5 | * purpose with or without fee is hereby granted, provided that the above | ||
| 6 | * copyright notice and this permission notice appear in all copies. | ||
| 7 | * | ||
| 8 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 9 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 10 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
| 11 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 12 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
| 13 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
| 14 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
| 15 | */ | ||
| 16 | #ifndef __GST_SNDIO_H__ | ||
| 17 | #define __GST_SNDIO_H__ | ||
| 18 | |||
| 19 | #include <sndio.h> | ||
| 20 | #include <gst/gst.h> | ||
| 21 | #include <gst/audio/gstaudiosink.h> | ||
| 22 | #include <gst/audio/gstaudiosrc.h> | ||
| 23 | #include <gst/audio/streamvolume.h> | ||
| 24 | |||
| 25 | enum | ||
| 26 | { | ||
| 27 | PROP_0, | ||
| 28 | PROP_DEVICE, | ||
| 29 | PROP_VOLUME, | ||
| 30 | PROP_MUTE | ||
| 31 | }; | ||
| 32 | |||
| 33 | #define GST_SNDIO_CAPS_STRING \ | ||
| 34 | "audio/x-raw, " \ | ||
| 35 | "format = (string) { " \ | ||
| 36 | "S8, U8, " \ | ||
| 37 | "S16LE, S16BE, U16LE, U16BE, " \ | ||
| 38 | "S32LE, S32BE, U32LE, U32BE, " \ | ||
| 39 | "S24_32LE, S24_32BE, U24_32LE, " \ | ||
| 40 | "U24_32BE, S24LE, S24BE, U24LE, U24BE " \ | ||
| 41 | "}, " \ | ||
| 42 | "layout = (string) interleaved, " \ | ||
| 43 | "rate = (int) [ 8000, 192000 ], " \ | ||
| 44 | "channels = (int) [1, 16]" | ||
| 45 | |||
| 46 | /* | ||
| 47 | * data common to src and sink | ||
| 48 | */ | ||
| 49 | struct gstsndio { | ||
| 50 | struct sio_hdl *hdl; | ||
| 51 | gchar *device; | ||
| 52 | gint mode; | ||
| 53 | gint bpf; /* bytes per frame */ | ||
| 54 | gint delay; /* bytes stored in the audio fifo */ | ||
| 55 | guint volume; /* volume level */ | ||
| 56 | GstCaps *cur_caps; /* saved capabilities of opened device */ | ||
| 57 | GObject *obj; /* for logging */ | ||
| 58 | gboolean driver_timestamps; | ||
| 59 | }; | ||
| 60 | |||
| 61 | #define GST_SNDIO_DELAY(s) ((s)->delay / (s)->bpf) | ||
| 62 | |||
| 63 | void gst_sndio_init (struct gstsndio *sio, GObject *obj); | ||
| 64 | void gst_sndio_finalize (struct gstsndio *sio); | ||
| 65 | GstCaps *gst_sndio_getcaps (struct gstsndio *sio, GstCaps * filter); | ||
| 66 | gboolean gst_sndio_open (struct gstsndio *sio, gint mode); | ||
| 67 | gboolean gst_sndio_close (struct gstsndio *sio); | ||
| 68 | gboolean gst_sndio_prepare (struct gstsndio *sio, GstAudioRingBufferSpec *spec); | ||
| 69 | gboolean gst_sndio_unprepare (struct gstsndio *sio); | ||
| 70 | void gst_sndio_set_property (struct gstsndio *sio, guint prop_id, | ||
| 71 | const GValue * value, GParamSpec * pspec); | ||
| 72 | void gst_sndio_get_property (struct gstsndio *sio, guint prop_id, | ||
| 73 | GValue * value, GParamSpec * pspec); | ||
| 74 | |||
| 75 | int gst_sndio_setpar(gpointer sio, GstAudioRingBufferSpec * spec, | ||
| 76 | int mode, struct sio_hdl *hdl); | ||
| 77 | GstCaps *gst_sndio_caps (gpointer sio, int mode, struct sio_hdl *hdl); | ||
| 78 | |||
| 79 | #endif | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/meson.build b/multimedia/gstreamer1/plugins-base/files/meson.build deleted file mode 100644 index be10f22..0000000 --- a/multimedia/gstreamer1/plugins-base/files/meson.build +++ /dev/null | |||
| @@ -1,19 +0,0 @@ | |||
| 1 | sndio_sources = [ | ||
| 2 | 'gstsndio.c', | ||
| 3 | 'sndiosink.c', | ||
| 4 | 'sndiosrc.c', | ||
| 5 | ] | ||
| 6 | |||
| 7 | sndio_dep = dependency('sndio', required : get_option('sndio')) | ||
| 8 | |||
| 9 | if sndio_dep.found() | ||
| 10 | gstsndio = library('gstsndio', | ||
| 11 | sndio_sources, | ||
| 12 | c_args : gst_plugins_base_args, | ||
| 13 | include_directories: [configinc, libsinc], | ||
| 14 | dependencies : [sndio_dep, audio_dep, tag_dep, gst_dep, gst_base_dep], | ||
| 15 | install : true, | ||
| 16 | install_dir : plugins_install_dir, | ||
| 17 | ) | ||
| 18 | pkgconfig.generate(gstsndio, install_dir : plugins_pkgconfig_install_dir) | ||
| 19 | endif | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/sndiosink.c b/multimedia/gstreamer1/plugins-base/files/sndiosink.c deleted file mode 100644 index cc68bd2..0000000 --- a/multimedia/gstreamer1/plugins-base/files/sndiosink.c +++ /dev/null | |||
| @@ -1,226 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2008 Jacob Meuser <jakemsr@sdf.lonestar.org> | ||
| 3 | * Copyright (C) 2012 Alexandre Ratchov <alex@caoua.org> | ||
| 4 | * | ||
| 5 | * Permission to use, copy, modify, and distribute this software for any | ||
| 6 | * purpose with or without fee is hereby granted, provided that the above | ||
| 7 | * copyright notice and this permission notice appear in all copies. | ||
| 8 | * | ||
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
| 12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
| 14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
| 15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
| 16 | */ | ||
| 17 | |||
| 18 | /** | ||
| 19 | * SECTION:element-sndiosink | ||
| 20 | * @see_also: #GstAutoAudioSink | ||
| 21 | * | ||
| 22 | * <refsect2> | ||
| 23 | * <para> | ||
| 24 | * This element outputs sound to a sound card using sndio. | ||
| 25 | * </para> | ||
| 26 | * <para> | ||
| 27 | * Simple example pipeline that plays an Ogg/Vorbis file via sndio: | ||
| 28 | * <programlisting> | ||
| 29 | * gst-launch -v filesrc location=foo.ogg ! decodebin ! audioconvert ! audioresample ! sndiosink | ||
| 30 | * </programlisting> | ||
| 31 | * </para> | ||
| 32 | * </refsect2> | ||
| 33 | */ | ||
| 34 | |||
| 35 | #ifdef HAVE_CONFIG_H | ||
| 36 | #include "config.h" | ||
| 37 | #endif | ||
| 38 | #include "sndiosink.h" | ||
| 39 | |||
| 40 | GST_DEBUG_CATEGORY_EXTERN (gst_sndio_debug); | ||
| 41 | #define GST_CAT_DEFAULT gst_sndio_debug | ||
| 42 | |||
| 43 | #define gst_sndiosink_parent_class parent_class | ||
| 44 | |||
| 45 | static GstStaticPadTemplate sndiosink_factory = | ||
| 46 | GST_STATIC_PAD_TEMPLATE ("sink", | ||
| 47 | GST_PAD_SINK, | ||
| 48 | GST_PAD_ALWAYS, | ||
| 49 | GST_STATIC_CAPS (GST_SNDIO_CAPS_STRING) | ||
| 50 | ); | ||
| 51 | |||
| 52 | G_DEFINE_TYPE_WITH_CODE (GstSndioSink, gst_sndiosink, GST_TYPE_AUDIO_SINK, | ||
| 53 | G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, NULL)); | ||
| 54 | |||
| 55 | static void gst_sndiosink_finalize (GObject * object); | ||
| 56 | static GstCaps *gst_sndiosink_getcaps (GstBaseSink * bsink, | ||
| 57 | GstCaps * filter); | ||
| 58 | static gboolean gst_sndiosink_open (GstAudioSink * asink); | ||
| 59 | static gboolean gst_sndiosink_close (GstAudioSink * asink); | ||
| 60 | static gboolean gst_sndiosink_prepare (GstAudioSink * asink, | ||
| 61 | GstAudioRingBufferSpec * spec); | ||
| 62 | static gboolean gst_sndiosink_unprepare (GstAudioSink * asink); | ||
| 63 | static gint gst_sndiosink_write (GstAudioSink * asink, gpointer data, | ||
| 64 | guint length); | ||
| 65 | static guint gst_sndiosink_delay (GstAudioSink * asink); | ||
| 66 | static void gst_sndiosink_reset (GstAudioSink * asink); | ||
| 67 | static void gst_sndiosink_set_property (GObject * object, guint prop_id, | ||
| 68 | const GValue * value, GParamSpec * pspec); | ||
| 69 | static void gst_sndiosink_get_property (GObject * object, guint prop_id, | ||
| 70 | GValue * value, GParamSpec * pspec); | ||
| 71 | |||
| 72 | static void | ||
| 73 | gst_sndiosink_init (GstSndioSink * sink) | ||
| 74 | { | ||
| 75 | gst_sndio_init (&sink->sndio, G_OBJECT(sink)); | ||
| 76 | } | ||
| 77 | |||
| 78 | static void | ||
| 79 | gst_sndiosink_finalize (GObject * object) | ||
| 80 | { | ||
| 81 | GstSndioSink *sink = GST_SNDIOSINK (object); | ||
| 82 | |||
| 83 | gst_sndio_finalize (&sink->sndio); | ||
| 84 | G_OBJECT_CLASS (parent_class)->finalize (object); | ||
| 85 | } | ||
| 86 | |||
| 87 | static GstCaps * | ||
| 88 | gst_sndiosink_getcaps (GstBaseSink * bsink, GstCaps * filter) | ||
| 89 | { | ||
| 90 | GstSndioSink *sink = GST_SNDIOSINK (bsink); | ||
| 91 | |||
| 92 | return gst_sndio_getcaps (&sink->sndio, filter); | ||
| 93 | } | ||
| 94 | |||
| 95 | static gboolean | ||
| 96 | gst_sndiosink_open (GstAudioSink * asink) | ||
| 97 | { | ||
| 98 | GstSndioSink *sink = GST_SNDIOSINK (asink); | ||
| 99 | |||
| 100 | return gst_sndio_open (&sink->sndio, SIO_PLAY); | ||
| 101 | } | ||
| 102 | |||
| 103 | static gboolean | ||
| 104 | gst_sndiosink_close (GstAudioSink * asink) | ||
| 105 | { | ||
| 106 | GstSndioSink *sink = GST_SNDIOSINK (asink); | ||
| 107 | |||
| 108 | return gst_sndio_close (&sink->sndio); | ||
| 109 | } | ||
| 110 | |||
| 111 | static gboolean | ||
| 112 | gst_sndiosink_prepare (GstAudioSink * asink, GstAudioRingBufferSpec * spec) | ||
| 113 | { | ||
| 114 | GstSndioSink *sink = GST_SNDIOSINK (asink); | ||
| 115 | |||
| 116 | return gst_sndio_prepare (&sink->sndio, spec); | ||
| 117 | } | ||
| 118 | |||
| 119 | static gboolean | ||
| 120 | gst_sndiosink_unprepare (GstAudioSink * asink) | ||
| 121 | { | ||
| 122 | GstSndioSink *sink = GST_SNDIOSINK (asink); | ||
| 123 | |||
| 124 | return gst_sndio_unprepare (&sink->sndio); | ||
| 125 | } | ||
| 126 | |||
| 127 | static gint | ||
| 128 | gst_sndiosink_write (GstAudioSink * asink, gpointer data, guint length) | ||
| 129 | { | ||
| 130 | GstSndioSink *sink = GST_SNDIOSINK (asink); | ||
| 131 | guint done; | ||
| 132 | |||
| 133 | if (length == 0) | ||
| 134 | return 0; | ||
| 135 | done = sio_write (sink->sndio.hdl, data, length); | ||
| 136 | if (done == 0) { | ||
| 137 | GST_ELEMENT_ERROR (sink, RESOURCE, WRITE, | ||
| 138 | ("Failed to write data to sndio"), (NULL)); | ||
| 139 | return 0; | ||
| 140 | } | ||
| 141 | sink->sndio.delay += done; | ||
| 142 | return done; | ||
| 143 | } | ||
| 144 | |||
| 145 | static guint | ||
| 146 | gst_sndiosink_delay (GstAudioSink * asink) | ||
| 147 | { | ||
| 148 | GstSndioSink *sink = GST_SNDIOSINK (asink); | ||
| 149 | |||
| 150 | return GST_SNDIO_DELAY(&sink->sndio); | ||
| 151 | } | ||
| 152 | |||
| 153 | static void | ||
| 154 | gst_sndiosink_reset (GstAudioSink * asink) | ||
| 155 | { | ||
| 156 | } | ||
| 157 | |||
| 158 | static void | ||
| 159 | gst_sndiosink_set_property (GObject * object, guint prop_id, | ||
| 160 | const GValue * value, GParamSpec * pspec) | ||
| 161 | { | ||
| 162 | GstSndioSink *sink = GST_SNDIOSINK (object); | ||
| 163 | |||
| 164 | gst_sndio_set_property (&sink->sndio, prop_id, value, pspec); | ||
| 165 | } | ||
| 166 | |||
| 167 | static void | ||
| 168 | gst_sndiosink_get_property (GObject * object, guint prop_id, GValue * value, | ||
| 169 | GParamSpec * pspec) | ||
| 170 | { | ||
| 171 | GstSndioSink *sink = GST_SNDIOSINK (object); | ||
| 172 | |||
| 173 | gst_sndio_get_property (&sink->sndio, prop_id, value, pspec); | ||
| 174 | } | ||
| 175 | |||
| 176 | static void | ||
| 177 | gst_sndiosink_class_init (GstSndioSinkClass * klass) | ||
| 178 | { | ||
| 179 | GObjectClass *gobject_class; | ||
| 180 | GstElementClass *gstelement_class; | ||
| 181 | GstBaseSinkClass *gstbasesink_class; | ||
| 182 | GstAudioBaseSinkClass *gstbaseaudiosink_class; | ||
| 183 | GstAudioSinkClass *gstaudiosink_class; | ||
| 184 | |||
| 185 | gobject_class = (GObjectClass *) klass; | ||
| 186 | gstelement_class = (GstElementClass *) klass; | ||
| 187 | gstbasesink_class = (GstBaseSinkClass *) klass; | ||
| 188 | gstbaseaudiosink_class = (GstAudioBaseSinkClass *) klass; | ||
| 189 | gstaudiosink_class = (GstAudioSinkClass *) klass; | ||
| 190 | |||
| 191 | parent_class = g_type_class_peek_parent (klass); | ||
| 192 | |||
| 193 | gobject_class->finalize = gst_sndiosink_finalize; | ||
| 194 | gobject_class->get_property = gst_sndiosink_get_property; | ||
| 195 | gobject_class->set_property = gst_sndiosink_set_property; | ||
| 196 | |||
| 197 | gst_element_class_set_static_metadata (gstelement_class, | ||
| 198 | "Audio sink (sndio)", "Sink/Audio", | ||
| 199 | "Output to a sound card via sndio", | ||
| 200 | "Jacob Meuser <jakemsr@sdf.lonestar.org>"); | ||
| 201 | |||
| 202 | gst_element_class_add_pad_template (gstelement_class, | ||
| 203 | gst_static_pad_template_get (&sndiosink_factory)); | ||
| 204 | |||
| 205 | gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_sndiosink_getcaps); | ||
| 206 | gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_sndiosink_open); | ||
| 207 | gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_sndiosink_prepare); | ||
| 208 | gstaudiosink_class->unprepare = GST_DEBUG_FUNCPTR (gst_sndiosink_unprepare); | ||
| 209 | gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_sndiosink_close); | ||
| 210 | gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_sndiosink_write); | ||
| 211 | gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_sndiosink_delay); | ||
| 212 | gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_sndiosink_reset); | ||
| 213 | |||
| 214 | g_object_class_install_property (gobject_class, PROP_DEVICE, | ||
| 215 | g_param_spec_string ("device", "Device", | ||
| 216 | "sndio device as defined in sndio(7)", | ||
| 217 | SIO_DEVANY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | ||
| 218 | g_object_class_install_property (gobject_class, PROP_VOLUME, | ||
| 219 | g_param_spec_double ("volume", "Volume", | ||
| 220 | "Linear volume of this stream, 1.0=100%", 0.0, 1.0, | ||
| 221 | 1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | ||
| 222 | g_object_class_install_property (gobject_class, PROP_MUTE, | ||
| 223 | g_param_spec_boolean ("mute", "Mute", | ||
| 224 | "Mute state of this stream", FALSE, | ||
| 225 | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | ||
| 226 | } | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/sndiosink.h b/multimedia/gstreamer1/plugins-base/files/sndiosink.h deleted file mode 100644 index 314e622..0000000 --- a/multimedia/gstreamer1/plugins-base/files/sndiosink.h +++ /dev/null | |||
| @@ -1,57 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2008 Jacob Meuser <jakemsr@sdf.lonestar.org> | ||
| 3 | * Copyright (C) 2012 Alexandre Ratchov <alex@caoua.org> | ||
| 4 | * | ||
| 5 | * Permission to use, copy, modify, and distribute this software for any | ||
| 6 | * purpose with or without fee is hereby granted, provided that the above | ||
| 7 | * copyright notice and this permission notice appear in all copies. | ||
| 8 | * | ||
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
| 12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
| 14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
| 15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
| 16 | */ | ||
| 17 | |||
| 18 | |||
| 19 | #ifndef __GST_SNDIOSINK_H__ | ||
| 20 | #define __GST_SNDIOSINK_H__ | ||
| 21 | |||
| 22 | #include <sndio.h> | ||
| 23 | |||
| 24 | #include <gst/gst.h> | ||
| 25 | #include <gst/audio/gstaudiosink.h> | ||
| 26 | #include "gstsndio.h" | ||
| 27 | |||
| 28 | G_BEGIN_DECLS | ||
| 29 | |||
| 30 | #define GST_TYPE_SNDIOSINK \ | ||
| 31 | (gst_sndiosink_get_type()) | ||
| 32 | #define GST_SNDIOSINK(obj) \ | ||
| 33 | (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SNDIOSINK,GstSndioSink)) | ||
| 34 | #define GST_SNDIOSINK_CLASS(klass) \ | ||
| 35 | (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SNDIOSINK,GstSndioSinkClass)) | ||
| 36 | #define GST_IS_SNDIOSINK(obj) \ | ||
| 37 | (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SNDIOSINK)) | ||
| 38 | #define GST_IS_SNDIOSINK_CLASS(klass) \ | ||
| 39 | (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SNDIOSINK)) | ||
| 40 | |||
| 41 | typedef struct _GstSndioSink GstSndioSink; | ||
| 42 | typedef struct _GstSndioSinkClass GstSndioSinkClass; | ||
| 43 | |||
| 44 | struct _GstSndioSink { | ||
| 45 | GstAudioSink sink; | ||
| 46 | struct gstsndio sndio; | ||
| 47 | }; | ||
| 48 | |||
| 49 | struct _GstSndioSinkClass { | ||
| 50 | GstAudioSinkClass parent_class; | ||
| 51 | }; | ||
| 52 | |||
| 53 | GType gst_sndiosink_get_type (void); | ||
| 54 | |||
| 55 | G_END_DECLS | ||
| 56 | |||
| 57 | #endif /* __GST_SNDIOSINK_H__ */ | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/sndiosrc.c b/multimedia/gstreamer1/plugins-base/files/sndiosrc.c deleted file mode 100644 index ee610e4..0000000 --- a/multimedia/gstreamer1/plugins-base/files/sndiosrc.c +++ /dev/null | |||
| @@ -1,228 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2008 Jacob Meuser <jakemsr@sdf.lonestar.org> | ||
| 3 | * Copyright (C) 2012 Alexandre Ratchov <alex@caoua.org> | ||
| 4 | * | ||
| 5 | * Permission to use, copy, modify, and distribute this software for any | ||
| 6 | * purpose with or without fee is hereby granted, provided that the above | ||
| 7 | * copyright notice and this permission notice appear in all copies. | ||
| 8 | * | ||
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
| 12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
| 14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
| 15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
| 16 | */ | ||
| 17 | |||
| 18 | /** | ||
| 19 | * SECTION:element-sndiosrc | ||
| 20 | * @see_also: #GstAutoAudioSrc | ||
| 21 | * | ||
| 22 | * <refsect2> | ||
| 23 | * <para> | ||
| 24 | * This element retrieves samples from a sound card using sndio. | ||
| 25 | * </para> | ||
| 26 | * <para> | ||
| 27 | * Simple example pipeline that records an Ogg/Vorbis file via sndio: | ||
| 28 | * <programlisting> | ||
| 29 | * gst-launch -v sndiosrc ! audioconvert ! vorbisenc ! oggmux ! filesink location=foo.ogg | ||
| 30 | * </programlisting> | ||
| 31 | * </para> | ||
| 32 | * </refsect2> | ||
| 33 | */ | ||
| 34 | |||
| 35 | #ifdef HAVE_CONFIG_H | ||
| 36 | #include "config.h" | ||
| 37 | #endif | ||
| 38 | |||
| 39 | #include "sndiosrc.h" | ||
| 40 | #include "gstsndio.h" | ||
| 41 | |||
| 42 | GST_DEBUG_CATEGORY_EXTERN (gst_sndio_debug); | ||
| 43 | #define GST_CAT_DEFAULT gst_sndio_debug | ||
| 44 | |||
| 45 | #define gst_sndiosrc_parent_class parent_class | ||
| 46 | G_DEFINE_TYPE_WITH_CODE (GstSndioSrc, gst_sndiosrc, GST_TYPE_AUDIO_SRC, | ||
| 47 | G_IMPLEMENT_INTERFACE (GST_TYPE_STREAM_VOLUME, NULL)); | ||
| 48 | |||
| 49 | static void gst_sndiosrc_finalize (GObject * object); | ||
| 50 | static GstCaps *gst_sndiosrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter); | ||
| 51 | static gboolean gst_sndiosrc_open (GstAudioSrc * asrc); | ||
| 52 | static gboolean gst_sndiosrc_close (GstAudioSrc * asrc); | ||
| 53 | static gboolean gst_sndiosrc_prepare (GstAudioSrc * asrc, | ||
| 54 | GstAudioRingBufferSpec * spec); | ||
| 55 | static gboolean gst_sndiosrc_unprepare (GstAudioSrc * asrc); | ||
| 56 | static guint gst_sndiosrc_read (GstAudioSrc * asrc, gpointer data, | ||
| 57 | guint length, GstClockTime * timestamp); | ||
| 58 | static guint gst_sndiosrc_delay (GstAudioSrc * asrc); | ||
| 59 | static void gst_sndiosrc_reset (GstAudioSrc * asrc); | ||
| 60 | static void gst_sndiosrc_set_property (GObject * object, guint prop_id, | ||
| 61 | const GValue * value, GParamSpec * pspec); | ||
| 62 | static void gst_sndiosrc_get_property (GObject * object, | ||
| 63 | guint prop_id, GValue * value, GParamSpec * pspec); | ||
| 64 | |||
| 65 | static GstStaticPadTemplate sndiosrc_factory = | ||
| 66 | GST_STATIC_PAD_TEMPLATE ("src", | ||
| 67 | GST_PAD_SRC, | ||
| 68 | GST_PAD_ALWAYS, | ||
| 69 | GST_STATIC_CAPS (GST_SNDIO_CAPS_STRING) | ||
| 70 | ); | ||
| 71 | |||
| 72 | static void | ||
| 73 | gst_sndiosrc_init (GstSndioSrc * src) | ||
| 74 | { | ||
| 75 | gst_sndio_init (&src->sndio, G_OBJECT(src)); | ||
| 76 | /* XXX not implemented */ | ||
| 77 | src->sndio.driver_timestamps = FALSE; | ||
| 78 | } | ||
| 79 | |||
| 80 | static void | ||
| 81 | gst_sndiosrc_finalize (GObject * object) | ||
| 82 | { | ||
| 83 | GstSndioSrc *src = GST_SNDIOSRC (object); | ||
| 84 | |||
| 85 | gst_sndio_finalize (&src->sndio); | ||
| 86 | G_OBJECT_CLASS (parent_class)->finalize (object); | ||
| 87 | } | ||
| 88 | |||
| 89 | static GstCaps * | ||
| 90 | gst_sndiosrc_getcaps (GstBaseSrc * bsrc, GstCaps * filter) | ||
| 91 | { | ||
| 92 | GstSndioSrc *src = GST_SNDIOSRC (bsrc); | ||
| 93 | |||
| 94 | return gst_sndio_getcaps (&src->sndio, filter); | ||
| 95 | } | ||
| 96 | |||
| 97 | static gboolean | ||
| 98 | gst_sndiosrc_open (GstAudioSrc * asrc) | ||
| 99 | { | ||
| 100 | GstSndioSrc *src = GST_SNDIOSRC (asrc); | ||
| 101 | |||
| 102 | return gst_sndio_open (&src->sndio, SIO_REC); | ||
| 103 | } | ||
| 104 | |||
| 105 | static gboolean | ||
| 106 | gst_sndiosrc_close (GstAudioSrc * asrc) | ||
| 107 | { | ||
| 108 | GstSndioSrc *src = GST_SNDIOSRC (asrc); | ||
| 109 | |||
| 110 | return gst_sndio_close (&src->sndio); | ||
| 111 | } | ||
| 112 | |||
| 113 | static gboolean | ||
| 114 | gst_sndiosrc_prepare (GstAudioSrc * asrc, GstAudioRingBufferSpec * spec) | ||
| 115 | { | ||
| 116 | GstSndioSrc *src = GST_SNDIOSRC (asrc); | ||
| 117 | |||
| 118 | return gst_sndio_prepare (&src->sndio, spec); | ||
| 119 | } | ||
| 120 | |||
| 121 | static gboolean | ||
| 122 | gst_sndiosrc_unprepare (GstAudioSrc * asrc) | ||
| 123 | { | ||
| 124 | GstSndioSrc *src = GST_SNDIOSRC (asrc); | ||
| 125 | |||
| 126 | return gst_sndio_unprepare (&src->sndio); | ||
| 127 | } | ||
| 128 | |||
| 129 | static guint | ||
| 130 | gst_sndiosrc_read (GstAudioSrc * asrc, gpointer data, guint length, | ||
| 131 | GstClockTime * timestamp) | ||
| 132 | { | ||
| 133 | GstSndioSrc *src = GST_SNDIOSRC (asrc); | ||
| 134 | guint done; | ||
| 135 | |||
| 136 | if (length == 0) | ||
| 137 | return 0; | ||
| 138 | done = sio_read (src->sndio.hdl, data, length); | ||
| 139 | if (done == 0) { | ||
| 140 | GST_ELEMENT_ERROR (src, RESOURCE, READ, | ||
| 141 | ("Failed to read data from sndio"), (NULL)); | ||
| 142 | return 0; | ||
| 143 | } | ||
| 144 | src->sndio.delay -= done; | ||
| 145 | return done; | ||
| 146 | } | ||
| 147 | |||
| 148 | static guint | ||
| 149 | gst_sndiosrc_delay (GstAudioSrc * asrc) | ||
| 150 | { | ||
| 151 | GstSndioSrc *src = GST_SNDIOSRC (asrc); | ||
| 152 | |||
| 153 | return GST_SNDIO_DELAY(&src->sndio); | ||
| 154 | } | ||
| 155 | |||
| 156 | static void | ||
| 157 | gst_sndiosrc_reset (GstAudioSrc * asrc) | ||
| 158 | { | ||
| 159 | } | ||
| 160 | |||
| 161 | static void | ||
| 162 | gst_sndiosrc_set_property (GObject * object, guint prop_id, | ||
| 163 | const GValue * value, GParamSpec * pspec) | ||
| 164 | { | ||
| 165 | GstSndioSrc *src = GST_SNDIOSRC (object); | ||
| 166 | |||
| 167 | gst_sndio_set_property (&src->sndio, prop_id, value, pspec); | ||
| 168 | } | ||
| 169 | |||
| 170 | static void | ||
| 171 | gst_sndiosrc_get_property (GObject * object, guint prop_id, GValue * value, | ||
| 172 | GParamSpec * pspec) | ||
| 173 | { | ||
| 174 | GstSndioSrc *src = GST_SNDIOSRC (object); | ||
| 175 | |||
| 176 | gst_sndio_get_property (&src->sndio, prop_id, value, pspec); | ||
| 177 | } | ||
| 178 | |||
| 179 | static void | ||
| 180 | gst_sndiosrc_class_init (GstSndioSrcClass * klass) | ||
| 181 | { | ||
| 182 | GObjectClass *gobject_class; | ||
| 183 | GstElementClass *gstelement_class; | ||
| 184 | GstBaseSrcClass *gstbasesrc_class; | ||
| 185 | GstAudioBaseSrcClass *gstbaseaudiosrc_class; | ||
| 186 | GstAudioSrcClass *gstaudiosrc_class; | ||
| 187 | gobject_class = (GObjectClass *) klass; | ||
| 188 | gstelement_class = (GstElementClass *) klass; | ||
| 189 | gstbasesrc_class = (GstBaseSrcClass *) klass; | ||
| 190 | gstbaseaudiosrc_class = (GstAudioBaseSrcClass *) klass; | ||
| 191 | gstaudiosrc_class = (GstAudioSrcClass *) klass; | ||
| 192 | |||
| 193 | parent_class = g_type_class_peek_parent (klass); | ||
| 194 | |||
| 195 | gobject_class->finalize = gst_sndiosrc_finalize; | ||
| 196 | gobject_class->get_property = gst_sndiosrc_get_property; | ||
| 197 | gobject_class->set_property = gst_sndiosrc_set_property; | ||
| 198 | |||
| 199 | gst_element_class_set_static_metadata (gstelement_class, | ||
| 200 | "Audio src (sndio)", "Src/Audio", | ||
| 201 | "Input from a sound card via sndio", | ||
| 202 | "Jacob Meuser <jakemsr@sdf.lonestar.org>"); | ||
| 203 | |||
| 204 | gst_element_class_add_pad_template (gstelement_class, | ||
| 205 | gst_static_pad_template_get (&sndiosrc_factory)); | ||
| 206 | |||
| 207 | gstbasesrc_class->get_caps = GST_DEBUG_FUNCPTR (gst_sndiosrc_getcaps); | ||
| 208 | gstaudiosrc_class->open = GST_DEBUG_FUNCPTR (gst_sndiosrc_open); | ||
| 209 | gstaudiosrc_class->prepare = GST_DEBUG_FUNCPTR (gst_sndiosrc_prepare); | ||
| 210 | gstaudiosrc_class->unprepare = GST_DEBUG_FUNCPTR (gst_sndiosrc_unprepare); | ||
| 211 | gstaudiosrc_class->close = GST_DEBUG_FUNCPTR (gst_sndiosrc_close); | ||
| 212 | gstaudiosrc_class->read = GST_DEBUG_FUNCPTR (gst_sndiosrc_read); | ||
| 213 | gstaudiosrc_class->delay = GST_DEBUG_FUNCPTR (gst_sndiosrc_delay); | ||
| 214 | gstaudiosrc_class->reset = GST_DEBUG_FUNCPTR (gst_sndiosrc_reset); | ||
| 215 | |||
| 216 | g_object_class_install_property (gobject_class, PROP_DEVICE, | ||
| 217 | g_param_spec_string ("device", "Device", | ||
| 218 | "sndio device as defined in sndio(7)", | ||
| 219 | SIO_DEVANY, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | ||
| 220 | g_object_class_install_property (gobject_class, PROP_VOLUME, | ||
| 221 | g_param_spec_double ("volume", "Volume", | ||
| 222 | "Linear volume of this stream, 1.0=100%", 0.0, 1.0, | ||
| 223 | 1.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | ||
| 224 | g_object_class_install_property (gobject_class, PROP_MUTE, | ||
| 225 | g_param_spec_boolean ("mute", "Mute", | ||
| 226 | "Mute state of this stream", FALSE, | ||
| 227 | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); | ||
| 228 | } | ||
diff --git a/multimedia/gstreamer1/plugins-base/files/sndiosrc.h b/multimedia/gstreamer1/plugins-base/files/sndiosrc.h deleted file mode 100644 index 83fd29c..0000000 --- a/multimedia/gstreamer1/plugins-base/files/sndiosrc.h +++ /dev/null | |||
| @@ -1,57 +0,0 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (C) 2008 Jacob Meuser <jakemsr@sdf.lonestar.org> | ||
| 3 | * Copyright (C) 2012 Alexandre Ratchov <alex@caoua.org> | ||
| 4 | * | ||
| 5 | * Permission to use, copy, modify, and distribute this software for any | ||
| 6 | * purpose with or without fee is hereby granted, provided that the above | ||
| 7 | * copyright notice and this permission notice appear in all copies. | ||
| 8 | * | ||
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | ||
| 12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
| 14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
| 15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
| 16 | */ | ||
| 17 | |||
| 18 | |||
| 19 | #ifndef __GST_SNDIOSRC_H__ | ||
| 20 | #define __GST_SNDIOSRC_H__ | ||
| 21 | |||
| 22 | #include <sndio.h> | ||
| 23 | |||
| 24 | #include <gst/gst.h> | ||
| 25 | #include <gst/audio/gstaudiosrc.h> | ||
| 26 | #include "gstsndio.h" | ||
| 27 | |||
| 28 | G_BEGIN_DECLS | ||
| 29 | |||
| 30 | #define GST_TYPE_SNDIOSRC \ | ||
| 31 | (gst_sndiosrc_get_type()) | ||
| 32 | #define GST_SNDIOSRC(obj) \ | ||
| 33 | (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SNDIOSRC,GstSndioSrc)) | ||
| 34 | #define GST_SNDIOSRC_CLASS(klass) \ | ||
| 35 | (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SNDIOSRC,GstSndioSrcClass)) | ||
| 36 | #define GST_IS_SNDIOSRC(obj) \ | ||
| 37 | (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SNDIOSRC)) | ||
| 38 | #define GST_IS_SNDIOSRC_CLASS(klass) \ | ||
| 39 | (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SNDIOSRC)) | ||
| 40 | |||
| 41 | typedef struct _GstSndioSrc GstSndioSrc; | ||
| 42 | typedef struct _GstSndioSrcClass GstSndioSrcClass; | ||
| 43 | |||
| 44 | struct _GstSndioSrc { | ||
| 45 | GstAudioSrc src; | ||
| 46 | struct gstsndio sndio; | ||
| 47 | }; | ||
| 48 | |||
| 49 | struct _GstSndioSrcClass { | ||
| 50 | GstAudioSrcClass parent_class; | ||
| 51 | }; | ||
| 52 | |||
| 53 | GType gst_sndiosrc_get_type (void); | ||
| 54 | |||
| 55 | G_END_DECLS | ||
| 56 | |||
| 57 | #endif /* __GST_SNDIOSRC_H__ */ | ||
