gstreamer/ext/sdl/sdlaudiosink.c

440 lines
10 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) <2005> Edgard Lima <edgard.lima@indt.org.br>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "sdlaudiosink.h"
#include <SDL_byteorder.h>
#include <string.h>
#include <unistd.h>
2012-01-27 14:49:58 +00:00
#include <gst/glib-compat-private.h>
GST_DEBUG_CATEGORY_EXTERN (sdl_debug);
#define GST_CAT_DEFAULT sdl_debug
static void gst_sdlaudio_sink_dispose (GObject * object);
static GstCaps *gst_sdlaudio_sink_getcaps (GstBaseSink * bsink);
static gboolean gst_sdlaudio_sink_open (GstAudioSink * asink);
static gboolean gst_sdlaudio_sink_close (GstAudioSink * asink);
static gboolean gst_sdlaudio_sink_prepare (GstAudioSink * asink,
GstRingBufferSpec * spec);
static gboolean gst_sdlaudio_sink_unprepare (GstAudioSink * asink);
static guint gst_sdlaudio_sink_write (GstAudioSink * asink, gpointer data,
guint length);
#if 0
static guint gst_sdlaudio_sink_delay (GstAudioSink * asink);
static void gst_sdlaudio_sink_reset (GstAudioSink * asink);
#endif
/* SdlaudioSink signals and args */
enum
{
LAST_SIGNAL
};
#define SEMAPHORE_INIT(s,f) \
do { \
s.cond = g_cond_new(); \
s.mutex = g_mutex_new(); \
s.mutexflag = f; \
} while(0)
#define SEMAPHORE_CLOSE(s) \
do { \
if ( s.cond ) { \
g_cond_free(s.cond); \
s.cond = NULL; \
} \
if ( s.mutex ) { \
g_mutex_free(s.mutex); \
s.mutex = NULL; \
} \
} while(0)
#define SEMAPHORE_UP(s) \
do \
{ \
g_mutex_lock(s.mutex); \
s.mutexflag = TRUE; \
g_mutex_unlock(s.mutex); \
g_cond_signal(s.cond); \
} while(0)
#define SEMAPHORE_DOWN(s, e) \
do \
{ \
while (1) { \
g_mutex_lock(s.mutex); \
if (!s.mutexflag) { \
if ( e ) { \
g_mutex_unlock(s.mutex); \
break; \
} \
g_cond_wait(s.cond,s.mutex); \
} \
else { \
s.mutexflag = FALSE; \
g_mutex_unlock(s.mutex); \
break; \
} \
g_mutex_unlock(s.mutex); \
} \
} while(0)
static GstStaticPadTemplate sdlaudiosink_sink_factory =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("audio/x-raw-int, "
"endianness = (int) { " G_STRINGIFY (G_BYTE_ORDER) " }, "
"signed = (boolean) { TRUE, FALSE }, "
"width = (int) 16, "
"depth = (int) 16, "
"rate = (int) [ 1, MAX ], "
"channels = (int) [ 1, 2 ]; "
"audio/x-raw-int, "
"endianness = (int) { " G_STRINGIFY (G_BYTE_ORDER) " }, "
"signed = (boolean) { TRUE, FALSE }, "
"width = (int) 8, "
"depth = (int) 8, "
"rate = (int) [ 1, MAX ], " "channels = (int) [ 1, 2 ]")
);
GST_BOILERPLATE (GstSDLAudioSink, gst_sdlaudio_sink, GstAudioSink,
GST_TYPE_AUDIO_SINK);
static void
gst_sdlaudio_sink_dispose (GObject * object)
{
GstSDLAudioSink *sdlaudiosink = GST_SDLAUDIOSINK (object);
SEMAPHORE_CLOSE (sdlaudiosink->semB);
SEMAPHORE_CLOSE (sdlaudiosink->semA);
if (sdlaudiosink->buffer) {
g_free (sdlaudiosink->buffer);
}
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_sdlaudio_sink_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_set_static_metadata (element_class, "SDL audio sink",
"Sink/Audio",
"Output to a sound card via SDLAUDIO",
"Edgard Lima <edgard.lima@indt.org.br>");
gst_element_class_add_static_pad_template (element_class,
&sdlaudiosink_sink_factory);
}
static void
gst_sdlaudio_sink_class_init (GstSDLAudioSinkClass * klass)
{
GObjectClass *gobject_class;
GstBaseSinkClass *gstbasesink_class;
GstAudioSinkClass *gstaudiosink_class;
gobject_class = (GObjectClass *) klass;
gstbasesink_class = (GstBaseSinkClass *) klass;
gstaudiosink_class = (GstAudioSinkClass *) klass;
gobject_class->dispose = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_dispose);
gstbasesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_getcaps);
gstaudiosink_class->open = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_open);
gstaudiosink_class->close = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_close);
gstaudiosink_class->prepare = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_prepare);
gstaudiosink_class->unprepare =
GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_unprepare);
gstaudiosink_class->write = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_write);
#if 0
gstaudiosink_class->delay = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_delay);
gstaudiosink_class->reset = GST_DEBUG_FUNCPTR (gst_sdlaudio_sink_reset);
#endif
}
static void
gst_sdlaudio_sink_init (GstSDLAudioSink * sdlaudiosink,
GstSDLAudioSinkClass * g_class)
{
GST_DEBUG ("initializing sdlaudiosink");
memset (&sdlaudiosink->fmt, 0, sizeof (SDL_AudioSpec));
sdlaudiosink->buffer = NULL;
sdlaudiosink->eos = FALSE;
SEMAPHORE_INIT (sdlaudiosink->semA, TRUE);
SEMAPHORE_INIT (sdlaudiosink->semB, FALSE);
}
static GstCaps *
gst_sdlaudio_sink_getcaps (GstBaseSink * bsink)
{
2010-11-25 17:49:23 +00:00
return gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD
(bsink)));
}
static gint
gst_sdlaudio_sink_get_format (GstBufferFormat fmt)
{
gint result = GST_UNKNOWN;
switch (fmt) {
case GST_U8:
result = AUDIO_U8;
break;
case GST_S8:
result = AUDIO_S8;
break;
case GST_S16_LE:
result = AUDIO_S16LSB;
break;
case GST_S16_BE:
result = AUDIO_S16MSB;
break;
case GST_U16_LE:
result = AUDIO_U16LSB;
break;
case GST_U16_BE:
result = AUDIO_U16MSB;
break;
default:
break;
}
return result;
}
static gboolean
gst_sdlaudio_sink_open (GstAudioSink * asink)
{
GstSDLAudioSink *sdlaudio;
sdlaudio = GST_SDLAUDIOSINK (asink);
if (SDL_Init (SDL_INIT_AUDIO) < 0) {
goto open_failed;
}
return TRUE;
open_failed:
{
GST_ELEMENT_ERROR (sdlaudio, LIBRARY, INIT,
("Unable to init SDL: %s\n", SDL_GetError ()), (NULL));
return FALSE;
}
}
static gboolean
gst_sdlaudio_sink_close (GstAudioSink * asink)
{
GstSDLAudioSink *sdlaudio = GST_SDLAUDIOSINK (asink);
sdlaudio->eos = TRUE;
SEMAPHORE_UP (sdlaudio->semA);
SEMAPHORE_UP (sdlaudio->semB);
SDL_QuitSubSystem (SDL_INIT_AUDIO);
return TRUE;
}
static guint
gst_sdlaudio_sink_write (GstAudioSink * asink, gpointer data, guint length)
{
GstSDLAudioSink *sdlaudio = GST_SDLAUDIOSINK (asink);
if (sdlaudio->fmt.size != length) {
GST_ERROR ("ring buffer segment length (%u) != sdl buffer len (%u)", length,
sdlaudio->fmt.size);
}
SEMAPHORE_DOWN (sdlaudio->semA, sdlaudio->eos);
if (!sdlaudio->eos)
memcpy (sdlaudio->buffer, data, length);
SEMAPHORE_UP (sdlaudio->semB);
return sdlaudio->fmt.size;
}
static void
mixaudio (void *unused, Uint8 * stream, int len)
{
GstSDLAudioSink *sdlaudio;
sdlaudio = GST_SDLAUDIOSINK (unused);
if (sdlaudio->fmt.size != len) {
GST_ERROR ("fmt buffer len (%u) != sdl callback len (%d)",
sdlaudio->fmt.size, len);
}
SEMAPHORE_DOWN (sdlaudio->semB, sdlaudio->eos);
if (!sdlaudio->eos)
SDL_MixAudio (stream, sdlaudio->buffer, sdlaudio->fmt.size,
SDL_MIX_MAXVOLUME);
SEMAPHORE_UP (sdlaudio->semA);
}
static gboolean
gst_sdlaudio_sink_prepare (GstAudioSink * asink, GstRingBufferSpec * spec)
{
GstSDLAudioSink *sdlaudio;
gint power2 = -1;
sdlaudio = GST_SDLAUDIOSINK (asink);
sdlaudio->fmt.format = gst_sdlaudio_sink_get_format (spec->format);
if (sdlaudio->fmt.format == 0)
goto wrong_format;
if (spec->width != 16 && spec->width != 8)
goto dodgy_width;
sdlaudio->fmt.freq = spec->rate;
sdlaudio->fmt.channels = spec->channels;
sdlaudio->fmt.samples =
spec->segsize / (spec->channels * ((sdlaudio->fmt.format & 0xFF) >> 3));
sdlaudio->fmt.callback = mixaudio;
sdlaudio->fmt.userdata = sdlaudio;
GST_DEBUG ("set segsize: %d, segtotal: %d, samples: %d", spec->segsize,
spec->segtotal, sdlaudio->fmt.samples);
while (sdlaudio->fmt.samples) {
sdlaudio->fmt.samples >>= 1;
++power2;
}
sdlaudio->fmt.samples = 1;
sdlaudio->fmt.samples <<= power2;
GST_DEBUG ("set segsize: %d, segtotal: %d, samples: %d", spec->segsize,
spec->segtotal, sdlaudio->fmt.samples);
if (SDL_OpenAudio (&sdlaudio->fmt, NULL) < 0) {
goto unable_open;
}
spec->segsize = sdlaudio->fmt.size;
sdlaudio->buffer = g_malloc (sdlaudio->fmt.size);
memset (sdlaudio->buffer, sdlaudio->fmt.silence, sdlaudio->fmt.size);
GST_DEBUG ("set segsize: %d, segtotal: %d, samples: %d", spec->segsize,
spec->segtotal, sdlaudio->fmt.samples);
spec->bytes_per_sample =
spec->channels * ((sdlaudio->fmt.format & 0xFF) >> 3);
memset (spec->silence_sample, sdlaudio->fmt.silence, spec->bytes_per_sample);
SDL_PauseAudio (0);
return TRUE;
unable_open:
{
GST_ELEMENT_ERROR (sdlaudio, RESOURCE, OPEN_READ,
("Unable to open audio: %s", SDL_GetError ()), (NULL));
return FALSE;
}
wrong_format:
{
GST_ELEMENT_ERROR (sdlaudio, RESOURCE, OPEN_READ,
("Unable to get format %d", spec->format), (NULL));
return FALSE;
}
dodgy_width:
{
GST_ELEMENT_ERROR (sdlaudio, RESOURCE, OPEN_READ,
("unexpected width %d", spec->width), (NULL));
return FALSE;
}
}
static gboolean
gst_sdlaudio_sink_unprepare (GstAudioSink * asink)
{
SDL_CloseAudio ();
return TRUE;
#if 0
if (!gst_sdlaudio_sink_close (asink))
goto couldnt_close;
if (!gst_sdlaudio_sink_open (asink))
goto couldnt_reopen;
return TRUE;
couldnt_close:
{
GST_DEBUG ("Could not close the audio device");
return FALSE;
}
couldnt_reopen:
{
GST_DEBUG ("Could not reopen the audio device");
return FALSE;
}
#endif
}
#if 0
static guint
gst_sdlaudio_sink_delay (GstAudioSink * asink)
{
GstSDLAudioSink *sdlaudio;
sdlaudio = GST_SDLAUDIOSINK (asink);
return 0;
}
static void
gst_sdlaudio_sink_reset (GstAudioSink * asink)
{
}
#endif