summaryrefslogtreecommitdiffstats
path: root/ext/xine/xineaudiodec.c
diff options
context:
space:
mode:
Diffstat (limited to 'ext/xine/xineaudiodec.c')
-rw-r--r--ext/xine/xineaudiodec.c556
1 files changed, 556 insertions, 0 deletions
diff --git a/ext/xine/xineaudiodec.c b/ext/xine/xineaudiodec.c
new file mode 100644
index 00000000..3d31ef9a
--- /dev/null
+++ b/ext/xine/xineaudiodec.c
@@ -0,0 +1,556 @@
+/* GStreamer
+ * Copyright (C) 2004 Benjamin Otte <in7y118@public.uni-hamburg.de>
+ *
+ * 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 details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <gst/gst.h>
+#include "gstxine.h"
+#include <xine/xine_internal.h>
+#include <xine/plugin_catalog.h>
+
+#define GST_TYPE_XINE_AUDIO_DEC \
+ (gst_xine_audio_dec_get_type())
+#define GST_XINE_AUDIO_DEC(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_XINE_AUDIO_DEC,GstXineAudioDec))
+#define GST_XINE_AUDIO_DEC_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_XINE_AUDIO_DEC, GstXineAudioDecClass))
+#define GST_XINE_AUDIO_DEC_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_XINE_AUDIO_DEC,GstXineAudioDecClass))
+#define GST_IS_XINE_AUDIO_DEC(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_XINE_AUDIO_DEC))
+#define GST_IS_XINE_AUDIO_DEC_CLASS(obj) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_XINE_AUDIO_DEC))
+
+GType gst_xine_audio_dec_get_type (void);
+
+typedef struct _GstXineAudioDec GstXineAudioDec;
+typedef struct _GstXineAudioDecClass GstXineAudioDecClass;
+
+struct _GstXineAudioDec
+{
+ GstXine parent;
+
+ GstPad * sinkpad;
+ GstPad * srcpad;
+
+ audio_decoder_t * decoder;
+ guint32 format;
+ xine_waveformatex wave;
+ gboolean setup;
+};
+
+struct _GstXineAudioDecClass
+{
+ GstXineClass parent_class;
+
+ plugin_node_t * plugin_node;
+};
+
+/*** xine audio driver wrapper ************************************************/
+
+typedef struct {
+ xine_ao_driver_t driver;
+ GstXineAudioDec * xine;
+ gboolean open;
+} GstXineAudioDriver;
+
+static guint32
+_driver_get_capabilities (xine_ao_driver_t *driver)
+{
+ /* FIXME: add more when gst handles more than 2 channels */
+ return AO_CAP_MODE_MONO | AO_CAP_MODE_STEREO | AO_CAP_8BITS;
+}
+
+static gint
+_driver_get_property (xine_ao_driver_t *driver, int property)
+{
+ return 0;
+}
+
+static gint
+_driver_set_property (xine_ao_driver_t * driver, int property, int value)
+{
+ return ~value;
+}
+
+static gint
+_driver_open (xine_ao_driver_t *driver, xine_stream_t *stream, guint32 bits, guint32 rate, int mode)
+{
+ GstCaps *caps;
+ GstXineAudioDriver *xine = ((GstXineAudioDriver *) driver);
+
+ caps = gst_caps_new_simple ("audio/x-raw-int",
+ "endianness", G_TYPE_INT, G_BYTE_ORDER,
+ "width", G_TYPE_INT, (gint) bits,
+ "depth", G_TYPE_INT, (gint) bits,
+ "signed", G_TYPE_BOOLEAN, (bits == 8) ? FALSE : TRUE,
+ "channels", G_TYPE_INT, (mode | AO_CAP_MODE_STEREO) ? 2 : 1,
+ "rate", G_TYPE_INT, rate,
+ NULL);
+
+ if (!gst_pad_set_explicit_caps (xine->xine->srcpad, caps)) {
+ gst_caps_free (caps);
+ driver->open = FALSE;
+ return -1;
+ }
+
+ xine->open = TRUE;
+ gst_caps_free (caps);
+ return rate;
+}
+
+static void
+_driver_close (xine_ao_driver_t *driver, xine_stream_t *stream)
+{
+ /* FIXME: unset explicit caps here? And how? */
+ driver->open = FALSE;
+}
+
+static void
+_driver_exit (xine_ao_driver_t *driver)
+{
+ g_free (driver);
+}
+
+static int
+_driver_control (xine_ao_driver_t *driver, int cmd, ...)
+{
+ return 0;
+}
+
+static void
+_driver_flush (xine_ao_driver_t *driver)
+{
+}
+
+static int
+_driver_status (xine_ao_driver_t *driver, xine_stream_t *stream, uint32_t *bits, uint32_t *rate, int *mode)
+{
+ const GstCaps *caps;
+ GstStructure *structure;
+ gint temp;
+ GstXineAudioDriver *xine = (GstXineAudioDriver *) driver;
+
+ if (xine->open == FALSE || !(caps = gst_pad_get_negotiated_caps (xine->xine->srcpad)))
+ return 0;
+
+ structure = gst_caps_get_structure (caps, 0);
+ *bits = 0; /* FIXME */
+ if (!gst_structure_get_int (structure, "rate", &temp)) {
+ g_assert_not_reached (); /* may never happen with negotiated caps */
+ return 0;
+ }
+ *rate = temp;
+ if (!gst_structure_get_int (structure, "channels", &temp)) {
+ g_assert_not_reached (); /* may never happen with negotiated caps */
+ return 0;
+ }
+ *mode = (temp == 2) ? AO_CAP_MODE_STEREO : AO_CAP_MODE_MONO;
+ if (!gst_structure_get_int (structure, "width", &temp)) {
+ g_assert_not_reached (); /* may never happen with negotiated caps */
+ return 0;
+ }
+ if (temp == 8)
+ *mode |= AO_CAP_8BITS;
+
+ return 1;
+}
+
+#define _DRIVER_BUFFER_SIZE 4096
+static audio_buffer_t *
+_driver_get_buffer (xine_ao_driver_t *driver)
+{
+ GstXineAudioDriver *xine = (GstXineAudioDriver *) driver;
+ audio_buffer_t *audio = g_new0 (audio_buffer_t, 1);
+
+ audio->mem = g_malloc (_DRIVER_BUFFER_SIZE);
+ audio->mem_size = _DRIVER_BUFFER_SIZE;
+ audio->stream = gst_xine_get_stream (GST_XINE (xine->xine));
+ /* FIXME: fill more fields */
+
+ return audio;
+}
+
+static void
+_driver_put_buffer (xine_ao_driver_t *driver, audio_buffer_t *audio, xine_stream_t *stream)
+{
+ GstXineAudioDriver *xine = (GstXineAudioDriver *) driver;
+ GstBuffer *buffer;
+
+ buffer = gst_buffer_new ();
+ GST_BUFFER_DATA (buffer) = (guint8 *) audio->mem;
+ GST_BUFFER_SIZE (buffer) = audio->mem_size;
+ GST_BUFFER_MAXSIZE (buffer) = audio->mem_size;
+ /* FIXME: fill more fields */
+ g_free (audio);
+ gst_pad_push (xine->xine->srcpad, GST_DATA (buffer));
+}
+
+static xine_ao_driver_t *
+_gst_xine_audio_dec_create_audio_driver (GstXine *xine)
+{
+ GstXineAudioDriver *driver = g_new (GstXineAudioDriver, 1);
+
+ driver->xine = GST_XINE_AUDIO_DEC (xine);
+ driver->open = FALSE;
+
+ driver->driver.get_buffer = _driver_get_buffer;
+ driver->driver.put_buffer = _driver_put_buffer;
+ driver->driver.get_capabilities = _driver_get_capabilities;
+ driver->driver.get_property = _driver_get_property;
+ driver->driver.set_property = _driver_set_property;
+ driver->driver.open = _driver_open;
+ driver->driver.close = _driver_close;
+ driver->driver.exit = _driver_exit;
+ driver->driver.control = _driver_control;
+ driver->driver.flush = _driver_flush;
+ driver->driver.status = _driver_status;
+
+ return (xine_ao_driver_t *) driver;
+}
+
+/** GstXineAudioDec ***********************************************************/
+
+GST_BOILERPLATE (GstXineAudioDec, gst_xine_audio_dec, GstXine, GST_TYPE_XINE)
+
+static void gst_xine_audio_dec_chain (GstPad *pad, GstData *in);
+static GstElementStateReturn
+ gst_xine_audio_dec_change_state (GstElement *element);
+
+/* this function handles the link with other plug-ins */
+static GstPadLinkReturn
+gst_xine_audio_dec_sink_link (GstPad *pad, const GstCaps *caps)
+{
+ guint temp;
+ GstStructure *structure;
+ GstXineAudioDec *xine = GST_XINE_AUDIO_DEC (gst_object_get_parent (GST_OBJECT (pad)));
+
+ xine->format = gst_xine_get_format_for_caps (caps);
+ if (xine->format == 0) return GST_PAD_LINK_REFUSED;
+
+ /* get setup data */
+ xine->setup = FALSE;
+ structure = gst_caps_get_structure (caps, 0);
+ if (gst_structure_get_int (structure, "channels", &temp))
+ xine->wave.nChannels = temp;
+ if (gst_structure_get_int (structure, "rate", &temp))
+ xine->wave.nSamplesPerSec = temp;
+ xine->wave.wBitsPerSample = 16; /* FIXME: how do we figure this thing out? */
+ /* FIXME: fill wave header better */
+
+ return GST_PAD_LINK_OK;
+}
+
+static void
+gst_xine_audio_dec_base_init (gpointer g_class)
+{
+}
+
+static void
+gst_xine_audio_dec_class_init (GstXineAudioDecClass *klass)
+{
+ GstXineClass *xine = GST_XINE_CLASS (klass);
+ GstElementClass *element = GST_ELEMENT_CLASS (klass);
+
+ element->change_state = gst_xine_audio_dec_change_state;
+
+ xine->create_audio_driver = _gst_xine_audio_dec_create_audio_driver;
+}
+
+static void
+gst_xine_audio_dec_init (GstXineAudioDec *xine)
+{
+ xine->setup = FALSE;
+}
+
+static void
+gst_xine_audio_dec_event (GstXineAudioDec *xine, GstEvent *event)
+{
+ gst_pad_event_default (xine->sinkpad, event);
+}
+
+static void
+gst_xine_audio_dec_chain (GstPad *pad, GstData *in)
+{
+ G_GNUC_UNUSED buf_element_t buffer = { 0, };
+ GstXineAudioDec *xine = GST_XINE_AUDIO_DEC (gst_object_get_parent (GST_OBJECT (pad)));
+
+ if (GST_IS_EVENT (in)) {
+ gst_xine_audio_dec_event (xine, GST_EVENT (in));
+ return;
+ }
+
+ if (xine->format == 0) {
+ /* no caps yet */
+ GST_ELEMENT_ERROR (xine, CORE, NEGOTIATION, (NULL), ("buffer sent before doing caps nego"));
+ gst_data_unref (in);
+ return;
+ }
+
+ if (!xine->setup) {
+ buf_element_t element = { 0, };
+ guint8 stsd[150] = { 0, };
+ guint temp;
+ GstStructure *structure;
+ /* sent setup header */
+ element.type = xine->format;
+ element.decoder_flags = BUF_FLAG_HEADER;
+ element.decoder_info[0] = 0;
+ element.decoder_info[1] = xine->wave.nSamplesPerSec;
+ element.decoder_info[2] = xine->wave.wBitsPerSample;
+ element.decoder_info[3] = xine->wave.nChannels;
+ element.content = (guchar *) &xine->wave;
+ element.size = sizeof (xine_waveformatex);
+ xine->decoder->decode_data (xine->decoder, &element);
+ /* send stsd emulation to the decoder */
+ /* FIXME: qdm2 only right now */
+ g_assert (gst_pad_get_negotiated_caps (xine->sinkpad));
+ structure = gst_caps_get_structure (gst_pad_get_negotiated_caps (xine->sinkpad), 0);
+ *((guint32 *) &stsd[56]) = GUINT32_TO_BE (12);
+ memcpy (&stsd[60], "frmaQDM2", 8);
+ *((guint32 *) &stsd[68]) = GUINT32_TO_BE (36);
+ memcpy (&stsd[72], "QDCA", 4);
+ *((guint32 *) &stsd[76]) = GUINT32_TO_BE (1);
+ if (!gst_structure_get_int (structure, "channels", &temp))
+ temp = 0;
+ *((guint32 *) &stsd[80]) = GUINT32_TO_BE (temp);
+ if (!gst_structure_get_int (structure, "rate", &temp))
+ temp = 0;
+ *((guint32 *) &stsd[84]) = GUINT32_TO_BE (temp);
+ if (!gst_structure_get_int (structure, "bitrate", &temp))
+ temp = 0;
+ *((guint32 *) &stsd[88]) = GUINT32_TO_BE (temp);
+ if (!gst_structure_get_int (structure, "blocksize", &temp))
+ temp = 0;
+ *((guint32 *) &stsd[92]) = GUINT32_TO_BE (temp);
+ *((guint32 *) &stsd[96]) = GUINT32_TO_BE (256);
+ if (!gst_structure_get_int (structure, "framesize", &temp))
+ temp = 0;
+ *((guint32 *) &stsd[100]) = GUINT32_TO_BE (temp);
+ *((guint32 *) &stsd[104]) = GUINT32_TO_BE (28);
+ memcpy (&stsd[108], "QDCP", 4);
+ *((guint32 *) &stsd[112]) = GUINT32_TO_BE (1065353216);
+ *((guint32 *) &stsd[116]) = GUINT32_TO_BE (0);
+ *((guint32 *) &stsd[120]) = GUINT32_TO_BE (1065353216);
+ *((guint32 *) &stsd[124]) = GUINT32_TO_BE (1065353216);
+ *((guint32 *) &stsd[128]) = GUINT32_TO_BE (27);
+ *((guint32 *) &stsd[132]) = GUINT32_TO_BE (8);
+ *((guint32 *) &stsd[136]) = GUINT32_TO_BE (0);
+ *((guint32 *) &stsd[140]) = GUINT32_TO_BE (24);
+ gst_util_dump_mem (stsd, 144);
+ element.decoder_flags = BUF_FLAG_SPECIAL;
+ element.decoder_info[1] = BUF_SPECIAL_STSD_ATOM;
+ element.decoder_info[2] = 144;
+ element.decoder_info[3] = 0;
+ element.decoder_info_ptr[2] = stsd;
+ element.size = 0;
+ element.content = 0;
+ xine->decoder->decode_data (xine->decoder, &element);
+
+ xine->setup = TRUE;
+ }
+
+ gst_buffer_to_xine_buffer (&buffer, GST_BUFFER (in));
+ buffer.type = xine->format;
+ xine->decoder->decode_data (xine->decoder, &buffer);
+ gst_data_unref (in);
+}
+
+static audio_decoder_t *
+_load_decoder (GstXineAudioDec* dec)
+{
+ xine_stream_t *stream = gst_xine_get_stream (GST_XINE (dec));
+ plugin_catalog_t *catalog = stream->xine->plugin_catalog;
+ plugin_node_t *node = GST_XINE_AUDIO_DEC_GET_CLASS (dec)->plugin_node;
+ audio_decoder_t *ret;
+
+ /* FIXME: this is really hacky, but how to force xine to load a plugin? */
+ /* how it works: xine can load a plugin for a particular stream type.
+ * We just take one type, which should not have plugins attached to it,
+ * attach our plugin and load it */
+ g_assert (catalog->audio_decoder_map[DECODER_MAX - 1][0] == NULL);
+ catalog->audio_decoder_map[DECODER_MAX - 1][0] = node;
+ ret = _x_get_audio_decoder (stream, DECODER_MAX - 1);
+ catalog->audio_decoder_map[DECODER_MAX - 1][0] = NULL;
+
+ return ret;
+}
+
+static GstElementStateReturn
+gst_xine_audio_dec_change_state (GstElement *element)
+{
+ GstXineAudioDec *xine = GST_XINE_AUDIO_DEC (element);
+
+ switch (GST_STATE_TRANSITION (element)) {
+ case GST_STATE_NULL_TO_READY:
+ xine->decoder = _load_decoder (xine);
+ if (!xine->decoder)
+ return GST_STATE_FAILURE;
+ break;
+ case GST_STATE_READY_TO_PAUSED:
+ break;
+ case GST_STATE_PAUSED_TO_PLAYING:
+ break;
+ case GST_STATE_PLAYING_TO_PAUSED:
+ break;
+ case GST_STATE_PAUSED_TO_READY:
+ break;
+ case GST_STATE_READY_TO_NULL:
+ xine->setup = FALSE;
+ _x_free_audio_decoder (gst_xine_get_stream (GST_XINE (xine)), xine->decoder);
+ break;
+ default:
+ GST_ERROR_OBJECT (element, "invalid state change");
+ break;
+ }
+
+ return GST_CALL_PARENT_WITH_DEFAULT (GST_ELEMENT_CLASS, change_state, (element), GST_STATE_SUCCESS);
+}
+
+/** GstXineAudioDec subclasses ************************************************/
+
+static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE (
+ "src",
+ GST_PAD_SRC,
+ GST_PAD_ALWAYS,
+ GST_STATIC_CAPS (
+ "audio/x-raw-int, "
+ "endianness = (int) BYTE_ORDER, "
+ "signed = (boolean) TRUE, "
+ "width = (int) 16, "
+ "depth = (int) 16, "
+ "rate = (int) [ 1, MAX ], "
+ "channels = (int) [ 1, 2 ]; "
+ "audio/x-raw-int, "
+ "signed = (boolean) FALSE, "
+ "width = (int) 8, "
+ "depth = (int) 8, "
+ "rate = (int) [ 1, MAX ], "
+ "channels = (int) [ 1, 2 ]"
+ )
+);
+
+static void
+gst_xine_audio_dec_subclass_init (gpointer g_class, gpointer class_data)
+{
+ GstXineAudioDecClass *xine_class = GST_XINE_AUDIO_DEC_CLASS (g_class);
+ GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
+ GstElementDetails details = GST_ELEMENT_DETAILS (
+ NULL,
+ "Filter/Decoder/Audio",
+ NULL,
+ "Benjamin Otte <otte@gnome.org>"
+ );
+ GstPadTemplate *template;
+ guint i = 0;
+ GstCaps *caps = gst_caps_new_empty ();
+ decoder_info_t *dec;
+
+ xine_class->plugin_node = class_data;
+ dec = xine_class->plugin_node->info->special_info;
+ details.longname = g_strdup_printf ("%s xine audio decoder", xine_class->plugin_node->info->id);
+ details.description = g_strdup_printf ("decodes audio using the xine '%s' plugin", xine_class->plugin_node->info->id);
+ gst_element_class_set_details (element_class, &details);
+ g_free (details.longname);
+ g_free (details.description);
+
+ gst_element_class_add_pad_template (element_class,
+ gst_static_pad_template_get (&src_template));
+
+ while (dec->supported_types[i] != 0) {
+ const gchar *type_str = gst_xine_get_caps_for_format (dec->supported_types[i]);
+ if (type_str) {
+ gst_caps_append (caps, gst_caps_from_string (type_str));
+ }
+ i++;
+ }
+ template = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps);
+ gst_element_class_add_pad_template (element_class, template);
+}
+
+static void
+gst_xine_audio_dec_sub_init (GTypeInstance *instance, gpointer g_class)
+{
+ GstElementClass *klass = GST_ELEMENT_GET_CLASS (instance);
+ GstXineAudioDec *xine = GST_XINE_AUDIO_DEC (instance);
+
+ xine->sinkpad = gst_pad_new_from_template (
+ gst_element_class_get_pad_template (klass, "sink"), "sink");
+ gst_pad_set_link_function (xine->sinkpad, gst_xine_audio_dec_sink_link);
+ gst_pad_set_chain_function (xine->sinkpad, gst_xine_audio_dec_chain);
+ gst_element_add_pad (GST_ELEMENT (xine), xine->sinkpad);
+
+ xine->srcpad = gst_pad_new_from_template (
+ gst_element_class_get_pad_template (klass, "src"), "src");
+ gst_pad_use_explicit_caps (xine->srcpad);
+ gst_element_add_pad (GST_ELEMENT (xine), xine->srcpad);
+}
+
+gboolean
+gst_xine_audio_dec_init_plugin (GstPlugin *plugin)
+{
+ GTypeInfo plugin_info =
+ {
+ sizeof (GstXineAudioDecClass),
+ NULL,
+ NULL,
+ gst_xine_audio_dec_subclass_init,
+ NULL,
+ NULL,
+ sizeof (GstXineAudioDec),
+ 0,
+ gst_xine_audio_dec_sub_init,
+ };
+ xine_node_t *list;
+ GstXineClass *klass;
+
+ klass = g_type_class_ref (GST_TYPE_XINE);
+
+ list = klass->xine->plugin_catalog->audio->first;
+ while (list) {
+ plugin_node_t *node = list->content;
+ decoder_info_t *dec;
+ guint format = 0;
+
+ list = list->next;
+ if (!node) continue;
+
+ dec = node->info->special_info;
+ while (dec->supported_types[format] != 0) {
+ const gchar *caps = gst_xine_get_caps_for_format (dec->supported_types[format]);
+ if (caps) {
+ gchar *plugin_name = g_strdup_printf ("xineaudiodec_%s", node->info->id);
+ gchar *type_name = g_strdup_printf ("GstXineAudioDec%s", node->info->id);
+ GType type;
+ plugin_info.class_data = node;
+ type = g_type_register_static (GST_TYPE_XINE_AUDIO_DEC, type_name, &plugin_info, 0);
+ g_free (type_name);
+ if (!gst_element_register (plugin, plugin_name,
+ MAX (GST_RANK_MARGINAL, GST_RANK_MARGINAL * dec->priority / 10 + 1), type)) {
+ g_free (plugin_name);
+ return FALSE;
+ }
+ g_free (plugin_name);
+ }
+ format++;
+ }
+ }
+
+ g_type_class_unref (klass);
+ return TRUE;
+}
+
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-28 17:59:43 +0000