gstreamer/ext/xine/xineaudiodec.c

577 lines
17 KiB
C
Raw Normal View History

/* 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)
{
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;
}