mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-25 01:30:38 +00:00
ext/xine/: add first version of xine plugin wrapper. Currently only wraps the
Original commit message from CVS: 2004-02-20 Benjamin Otte <otte@gnome.org> * ext/xine/Makefile.am: * ext/xine/gstxine.h: * ext/xine/xine.c: * ext/xine/xineaudiodec.c: * ext/xine/xinecaps.c: add first version of xine plugin wrapper. Currently only wraps the QDM2 win32 DLL, and even that only in proof-of-concept quality. * configure.ac: * ext/Makefile.am: add xine plugin wrapper, disabled by default. Use --enable-xine to build. Note that it'll segfault on gst-register if you don't remove the goom and tvtime post plugins from xine. * gst/qtdemux/qtdemux.c: (gst_qtdemux_handle_sink_event), (qtdemux_parse), (qtdemux_parse_trak), (qtdemux_audio_caps): add extradata parsing for QDM2. change around debugging prints.
This commit is contained in:
Benjamin Otte
parent
fd2dd2337b
commit
ea5845cb2b
9 changed files with 997 additions and 15 deletions
19
ChangeLog
19
ChangeLog
|
|
@ -1,3 +1,22 @@
|
|||
2004-02-20 Benjamin Otte <otte@gnome.org>
|
||||
|
||||
* ext/xine/Makefile.am:
|
||||
* ext/xine/gstxine.h:
|
||||
* ext/xine/xine.c:
|
||||
* ext/xine/xineaudiodec.c:
|
||||
* ext/xine/xinecaps.c:
|
||||
add first version of xine plugin wrapper. Currently only wraps the
|
||||
QDM2 win32 DLL, and even that only in proof-of-concept quality.
|
||||
* configure.ac:
|
||||
* ext/Makefile.am:
|
||||
add xine plugin wrapper, disabled by default. Use --enable-xine to
|
||||
build. Note that it'll segfault on gst-register if you don't remove
|
||||
the goom and tvtime post plugins from xine.
|
||||
* gst/qtdemux/qtdemux.c: (gst_qtdemux_handle_sink_event),
|
||||
(qtdemux_parse), (qtdemux_parse_trak), (qtdemux_audio_caps):
|
||||
add extradata parsing for QDM2.
|
||||
change around debugging prints.
|
||||
|
||||
2004-02-19 Benjamin Otte <otte@gnome.org>
|
||||
|
||||
* ext/lame/gstlame.c: (gst_lame_chain):
|
||||
|
|
|
|||
|
|
@ -1320,6 +1320,14 @@ vorbis_synthesis_restart (v);
|
|||
CFLAGS="$ac_cflags_save"
|
||||
fi
|
||||
|
||||
dnl *** xine ***
|
||||
translit(dnm, m, l) AM_CONDITIONAL(USE_XINE, true)
|
||||
GST_CHECK_FEATURE(XINE, [xine wrapper], xine, [
|
||||
PKG_CHECK_MODULES(XINE, libxine >= 1.0.0, HAVE_XINE=yes, HAVE_XINE=no)
|
||||
AC_SUBST(XINE_CFLAGS)
|
||||
AC_SUBST(XINE_LIBS)
|
||||
],disabled)
|
||||
|
||||
dnl *** XVID ***
|
||||
translit(dnm, m, l) AM_CONDITIONAL(USE_XVID, true)
|
||||
GST_CHECK_FEATURE(XVID, [xvid plugins], xvid, [
|
||||
|
|
@ -1664,6 +1672,7 @@ ext/swfdec/Makefile
|
|||
ext/tarkin/Makefile
|
||||
ext/theora/Makefile
|
||||
ext/vorbis/Makefile
|
||||
ext/xine/Makefile
|
||||
ext/xvid/Makefile
|
||||
gst-libs/Makefile
|
||||
gst-libs/gst/Makefile
|
||||
|
|
|
|||
|
|
@ -310,6 +310,12 @@ else
|
|||
SPEEX_DIR=
|
||||
endif
|
||||
|
||||
if USE_XINE
|
||||
XINE_DIR=xine
|
||||
else
|
||||
XINE_DIR=
|
||||
endif
|
||||
|
||||
SUBDIRS=\
|
||||
$(A52DEC_DIR) \
|
||||
$(AALIB_DIR) \
|
||||
|
|
@ -361,6 +367,7 @@ SUBDIRS=\
|
|||
$(THEORA_DIR) \
|
||||
$(IVORBIS_DIR) \
|
||||
$(VORBIS_DIR) \
|
||||
$(XINE_DIR) \
|
||||
$(XVID_DIR)
|
||||
|
||||
DIST_SUBDIRS=\
|
||||
|
|
@ -415,4 +422,5 @@ DIST_SUBDIRS=\
|
|||
tarkin \
|
||||
theora \
|
||||
vorbis \
|
||||
xine \
|
||||
xvid
|
||||
|
|
|
|||
11
ext/xine/Makefile.am
Normal file
11
ext/xine/Makefile.am
Normal file
|
|
@ -0,0 +1,11 @@
|
|||
plugindir = $(libdir)/gstreamer-@GST_MAJORMINOR@
|
||||
|
||||
plugin_LTLIBRARIES = libgstxine.la
|
||||
|
||||
libgstxine_la_SOURCES = xine.c xinecaps.c xineaudiodec.c
|
||||
libgstxine_la_CFLAGS = $(GST_CFLAGS) $(XINE_CFLAGS)
|
||||
libgstxine_la_LIBADD = $(XINE_LIBS)
|
||||
libgstxine_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
|
||||
|
||||
noinst_HEADERS = gstxine.h
|
||||
|
||||
82
ext/xine/gstxine.h
Normal file
82
ext/xine/gstxine.h
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
/* 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.
|
||||
*/
|
||||
|
||||
#ifndef __GST_XINE_H__
|
||||
#define __GST_XINE_H__
|
||||
|
||||
#include <gst/gst.h>
|
||||
#include <xine.h>
|
||||
#include <xine/buffer.h>
|
||||
|
||||
G_BEGIN_DECLS
|
||||
|
||||
#define GST_TYPE_XINE \
|
||||
(gst_xine_get_type())
|
||||
#define GST_XINE(obj) \
|
||||
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_XINE,GstXine))
|
||||
#define GST_XINE_GET_CLASS(obj) \
|
||||
(G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_XINE, GstXineClass))
|
||||
#define GST_XINE_CLASS(klass) \
|
||||
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_XINE,GstXineClass))
|
||||
#define GST_IS_XINE(obj) \
|
||||
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_XINE))
|
||||
#define GST_IS_XINE_CLASS(obj) \
|
||||
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_XINE))
|
||||
|
||||
typedef struct _GstXine GstXine;
|
||||
typedef struct _GstXineClass GstXineClass;
|
||||
|
||||
struct _GstXine
|
||||
{
|
||||
GstElement element;
|
||||
|
||||
xine_stream_t * stream;
|
||||
xine_ao_driver_t * audio_driver;
|
||||
xine_vo_driver_t * video_driver;
|
||||
};
|
||||
|
||||
struct _GstXineClass
|
||||
{
|
||||
GstElementClass parent_class;
|
||||
|
||||
xine_t * xine;
|
||||
|
||||
xine_ao_driver_t * (* create_audio_driver) (GstXine * xine);
|
||||
xine_vo_driver_t * (* create_video_driver) (GstXine * xine);
|
||||
};
|
||||
|
||||
GType gst_xine_get_type (void);
|
||||
|
||||
xine_stream_t * gst_xine_get_stream (GstXine *xine);
|
||||
void gst_xine_free_stream (GstXine *xine);
|
||||
|
||||
void gst_buffer_to_xine_buffer (buf_element_t *element, GstBuffer *buffer);
|
||||
|
||||
/* conversion functions from xinecaps.c */
|
||||
|
||||
const gchar * gst_xine_get_caps_for_format (guint32 format);
|
||||
guint32 gst_xine_get_format_for_caps (const GstCaps *caps);
|
||||
|
||||
/* init functions for the plugins */
|
||||
|
||||
gboolean gst_xine_audio_dec_init_plugin (GstPlugin *plugin);
|
||||
|
||||
G_END_DECLS
|
||||
|
||||
#endif /* __GST_XINE_H__ */
|
||||
169
ext/xine/xine.c
Normal file
169
ext/xine/xine.c
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
/* 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.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
#endif
|
||||
|
||||
#include "gstxine.h"
|
||||
|
||||
GST_BOILERPLATE (GstXine, gst_xine, GstElement, GST_TYPE_ELEMENT)
|
||||
|
||||
static GstElementStateReturn gst_xine_change_state (GstElement * element);
|
||||
|
||||
static xine_ao_driver_t * _xine_create_audio_driver (GstXine * xine);
|
||||
static xine_vo_driver_t * _xine_create_video_driver (GstXine * xine);
|
||||
|
||||
|
||||
static void
|
||||
gst_xine_base_init (gpointer klass)
|
||||
{
|
||||
}
|
||||
|
||||
static void
|
||||
gst_xine_class_init (GstXineClass *klass)
|
||||
{
|
||||
GstElementClass *element = GST_ELEMENT_CLASS (klass);
|
||||
|
||||
klass->xine = xine_new ();
|
||||
xine_init (klass->xine);
|
||||
|
||||
klass->create_audio_driver = _xine_create_audio_driver;
|
||||
klass->create_video_driver = _xine_create_video_driver;
|
||||
|
||||
element->change_state = gst_xine_change_state;
|
||||
}
|
||||
|
||||
static void
|
||||
gst_xine_init (GstXine *filter)
|
||||
{
|
||||
}
|
||||
|
||||
static GstElementStateReturn
|
||||
gst_xine_change_state (GstElement *element)
|
||||
{
|
||||
GstXine *xine = GST_XINE (element);
|
||||
|
||||
switch (GST_STATE_TRANSITION (element)) {
|
||||
case GST_STATE_NULL_TO_READY:
|
||||
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:
|
||||
if (xine->stream != NULL)
|
||||
gst_xine_free_stream (xine);
|
||||
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);
|
||||
}
|
||||
|
||||
static xine_ao_driver_t *
|
||||
_xine_create_audio_driver (GstXine *xine)
|
||||
{
|
||||
return xine_open_audio_driver (GST_XINE_GET_CLASS (xine)->xine, "none", NULL);
|
||||
}
|
||||
|
||||
static xine_vo_driver_t *
|
||||
_xine_create_video_driver (GstXine *xine)
|
||||
{
|
||||
return xine_open_video_driver (GST_XINE_GET_CLASS (xine)->xine, "none", XINE_VISUAL_TYPE_NONE, NULL);
|
||||
}
|
||||
|
||||
xine_stream_t *
|
||||
gst_xine_get_stream (GstXine *xine)
|
||||
{
|
||||
if (!xine->stream) {
|
||||
GstXineClass *klass = GST_XINE_GET_CLASS (xine);
|
||||
g_assert (xine->video_driver == NULL);
|
||||
g_assert (xine->audio_driver == NULL);
|
||||
xine->audio_driver = klass->create_audio_driver (xine);
|
||||
xine->video_driver = klass->create_video_driver (xine);
|
||||
xine->stream = xine_stream_new (klass->xine, xine->audio_driver, xine->video_driver);
|
||||
|
||||
/* FIXME: fail gracefully */
|
||||
g_assert (xine->stream);
|
||||
}
|
||||
|
||||
return xine->stream;
|
||||
}
|
||||
|
||||
void
|
||||
gst_xine_free_stream (GstXine *xine)
|
||||
{
|
||||
g_return_if_fail (xine->stream != NULL);
|
||||
g_assert (xine->video_driver != NULL);
|
||||
g_assert (xine->audio_driver != NULL);
|
||||
|
||||
xine_dispose (xine->stream);
|
||||
xine->stream = NULL;
|
||||
xine_close_video_driver (GST_XINE_GET_CLASS (xine)->xine, xine->video_driver);
|
||||
xine->video_driver = NULL;
|
||||
xine_close_audio_driver (GST_XINE_GET_CLASS (xine)->xine, xine->audio_driver);
|
||||
xine->audio_driver = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
_free_xine_buf_element (buf_element_t *buffer)
|
||||
{
|
||||
gst_buffer_unref (GST_BUFFER (buffer->source));
|
||||
}
|
||||
|
||||
void
|
||||
gst_buffer_to_xine_buffer (buf_element_t *ret, GstBuffer *buffer)
|
||||
{
|
||||
g_return_if_fail (ret != NULL);
|
||||
g_return_if_fail (buffer != NULL);
|
||||
|
||||
/* FIXME: what's the difference? */
|
||||
ret->mem = GST_BUFFER_DATA (buffer);
|
||||
ret->content = GST_BUFFER_DATA (buffer);
|
||||
ret->size = GST_BUFFER_SIZE (buffer);
|
||||
ret->max_size = GST_BUFFER_MAXSIZE (buffer);
|
||||
/* FIXME: add more */
|
||||
ret->free_buffer = _free_xine_buf_element;
|
||||
ret->source = buffer;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
plugin_init (GstPlugin *plugin)
|
||||
{
|
||||
return gst_xine_audio_dec_init_plugin (plugin);
|
||||
}
|
||||
|
||||
GST_PLUGIN_DEFINE (
|
||||
GST_VERSION_MAJOR,
|
||||
GST_VERSION_MINOR,
|
||||
"xine",
|
||||
"wrapper for libxine (version "XINE_VERSION") plugins",
|
||||
plugin_init,
|
||||
VERSION,
|
||||
"GPL",
|
||||
GST_PACKAGE,
|
||||
GST_ORIGIN
|
||||
)
|
||||
556
ext/xine/xineaudiodec.c
Normal file
556
ext/xine/xineaudiodec.c
Normal file
|
|
@ -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;
|
||||
}
|
||||
|
||||
119
ext/xine/xinecaps.c
Normal file
119
ext/xine/xinecaps.c
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
/* 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 "gstxine.h"
|
||||
#include <xine/buffer.h>
|
||||
|
||||
typedef struct {
|
||||
guint32 xine;
|
||||
gchar * caps;
|
||||
} GstXineCapsMap;
|
||||
|
||||
static GstXineCapsMap _gst_xine_caps_map[] = {
|
||||
{ BUF_AUDIO_QDESIGN2, "audio/x-qdm2" },
|
||||
/* FIXME:
|
||||
#define BUF_AUDIO_A52 0x03000000
|
||||
#define BUF_AUDIO_MPEG 0x03010000
|
||||
#define BUF_AUDIO_LPCM_BE 0x03020000
|
||||
#define BUF_AUDIO_LPCM_LE 0x03030000
|
||||
#define BUF_AUDIO_WMAV1 0x03040000
|
||||
#define BUF_AUDIO_DTS 0x03050000
|
||||
#define BUF_AUDIO_MSADPCM 0x03060000
|
||||
#define BUF_AUDIO_MSIMAADPCM 0x03070000
|
||||
#define BUF_AUDIO_MSGSM 0x03080000
|
||||
#define BUF_AUDIO_VORBIS 0x03090000
|
||||
#define BUF_AUDIO_IMC 0x030a0000
|
||||
#define BUF_AUDIO_LH 0x030b0000
|
||||
#define BUF_AUDIO_VOXWARE 0x030c0000
|
||||
#define BUF_AUDIO_ACELPNET 0x030d0000
|
||||
#define BUF_AUDIO_AAC 0x030e0000
|
||||
#define BUF_AUDIO_DNET 0x030f0000
|
||||
#define BUF_AUDIO_VIVOG723 0x03100000
|
||||
#define BUF_AUDIO_DK3ADPCM 0x03110000
|
||||
#define BUF_AUDIO_DK4ADPCM 0x03120000
|
||||
#define BUF_AUDIO_ROQ 0x03130000
|
||||
#define BUF_AUDIO_QTIMAADPCM 0x03140000
|
||||
#define BUF_AUDIO_MAC3 0x03150000
|
||||
#define BUF_AUDIO_MAC6 0x03160000
|
||||
#define BUF_AUDIO_QDESIGN1 0x03170000
|
||||
#define BUF_AUDIO_QDESIGN2 0x03180000
|
||||
#define BUF_AUDIO_QCLP 0x03190000
|
||||
#define BUF_AUDIO_SMJPEG_IMA 0x031A0000
|
||||
#define BUF_AUDIO_VQA_IMA 0x031B0000
|
||||
#define BUF_AUDIO_MULAW 0x031C0000
|
||||
#define BUF_AUDIO_ALAW 0x031D0000
|
||||
#define BUF_AUDIO_GSM610 0x031E0000
|
||||
#define BUF_AUDIO_EA_ADPCM 0x031F0000
|
||||
#define BUF_AUDIO_WMAV2 0x03200000
|
||||
#define BUF_AUDIO_COOK 0x03210000
|
||||
#define BUF_AUDIO_ATRK 0x03220000
|
||||
#define BUF_AUDIO_14_4 0x03230000
|
||||
#define BUF_AUDIO_28_8 0x03240000
|
||||
#define BUF_AUDIO_SIPRO 0x03250000
|
||||
#define BUF_AUDIO_WMAV3 0x03260000
|
||||
#define BUF_AUDIO_INTERPLAY 0x03270000
|
||||
#define BUF_AUDIO_XA_ADPCM 0x03280000
|
||||
#define BUF_AUDIO_WESTWOOD 0x03290000
|
||||
#define BUF_AUDIO_DIALOGIC_IMA 0x032A0000
|
||||
#define BUF_AUDIO_NSF 0x032B0000
|
||||
#define BUF_AUDIO_FLAC 0x032C0000
|
||||
#define BUF_AUDIO_DV 0x032D0000
|
||||
#define BUF_AUDIO_WMAV 0x032E0000
|
||||
#define BUF_AUDIO_SPEEX 0x032F0000
|
||||
#define BUF_AUDIO_RAWPCM 0x03300000
|
||||
#define BUF_AUDIO_4X_ADPCM 0x03310000
|
||||
*/
|
||||
{ 0, NULL }
|
||||
};
|
||||
|
||||
const gchar *
|
||||
gst_xine_get_caps_for_format (guint32 format)
|
||||
{
|
||||
guint i = 0;
|
||||
|
||||
while (_gst_xine_caps_map[i].xine != 0) {
|
||||
if (_gst_xine_caps_map[i].xine == format)
|
||||
return _gst_xine_caps_map[i].caps;
|
||||
i++;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
guint32
|
||||
gst_xine_get_format_for_caps (const GstCaps *caps)
|
||||
{
|
||||
guint i = 0;
|
||||
GstCaps *compare, *intersect;
|
||||
|
||||
while (_gst_xine_caps_map[i].xine != 0) {
|
||||
compare = gst_caps_from_string (_gst_xine_caps_map[i].caps);
|
||||
intersect = gst_caps_intersect (caps, compare);
|
||||
gst_caps_free (compare);
|
||||
if (!gst_caps_is_empty (intersect)) {
|
||||
gst_caps_free (intersect);
|
||||
return _gst_xine_caps_map[i].xine;
|
||||
}
|
||||
gst_caps_free (intersect);
|
||||
i++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -153,7 +153,7 @@ static QtNodeType *qtdemux_type_get(guint32 fourcc);
|
|||
static void qtdemux_node_dump(GstQTDemux *qtdemux, GNode *node);
|
||||
static void qtdemux_parse_tree(GstQTDemux *qtdemux);
|
||||
static GstCaps *qtdemux_video_caps(GstQTDemux *qtdemux, guint32 fourcc, const guint8 *stsd_data);
|
||||
static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc);
|
||||
static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc, const guint8 *data);
|
||||
|
||||
static GType gst_qtdemux_get_type (void)
|
||||
{
|
||||
|
|
@ -284,7 +284,7 @@ static gboolean gst_qtdemux_handle_sink_event (GstQTDemux *qtdemux)
|
|||
gst_pad_event_default(qtdemux->sinkpad, event);
|
||||
return FALSE;
|
||||
case GST_EVENT_FLUSH:
|
||||
g_warning("flush event");
|
||||
//g_warning("flush event");
|
||||
break;
|
||||
case GST_EVENT_DISCONTINUOUS:
|
||||
GST_DEBUG ("discontinuous event\n");
|
||||
|
|
@ -780,15 +780,15 @@ static void qtdemux_parse(GstQTDemux *qtdemux, GNode *node, void *buffer, int le
|
|||
QtNodeType *type;
|
||||
void *end;
|
||||
|
||||
//g_print("qtdemux_parse %p %d\n",buffer, length);
|
||||
g_print("qtdemux_parse %p %d\n",buffer, length);
|
||||
|
||||
node_length = QTDEMUX_GUINT32_GET(buffer);
|
||||
fourcc = QTDEMUX_FOURCC_GET(buffer+4);
|
||||
|
||||
type = qtdemux_type_get(fourcc);
|
||||
|
||||
/*g_print("parsing '" GST_FOURCC_FORMAT "', length=%d\n",
|
||||
GST_FOURCC_ARGS(fourcc), node_length);*/
|
||||
g_print("parsing '" GST_FOURCC_FORMAT "', length=%d\n",
|
||||
GST_FOURCC_ARGS(fourcc), node_length);
|
||||
|
||||
if(type->flags & QT_CONTAINER){
|
||||
void *buf;
|
||||
|
|
@ -1301,20 +1301,22 @@ static void qtdemux_parse_trak(GstQTDemux *qtdemux, GNode *trak)
|
|||
g_print("sample rate: %g\n", QTDEMUX_FP32_GET(stsd->data+offset + 16));
|
||||
stream->rate = QTDEMUX_FP32_GET(stsd->data+offset + 16);
|
||||
|
||||
offset = 52;
|
||||
if(version == 0x00010000){
|
||||
g_print("samples/packet: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 20));
|
||||
stream->samples_per_packet = QTDEMUX_GUINT32_GET(stsd->data+offset + 20);
|
||||
g_print("bytes/packet: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 24));
|
||||
g_print("bytes/frame: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 28));
|
||||
stream->bytes_per_frame = QTDEMUX_GUINT32_GET(stsd->data+offset + 28);
|
||||
g_print("bytes/sample: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 32));
|
||||
g_print("samples/packet: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset));
|
||||
stream->samples_per_packet = QTDEMUX_GUINT32_GET(stsd->data+offset);
|
||||
g_print("bytes/packet: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 4));
|
||||
g_print("bytes/frame: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 8));
|
||||
stream->bytes_per_frame = QTDEMUX_GUINT32_GET(stsd->data+offset + 8);
|
||||
g_print("bytes/sample: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 12));
|
||||
offset = 68;
|
||||
} else {
|
||||
stream->bytes_per_frame = stream->n_channels * QTDEMUX_GUINT16_GET(stsd->data+offset + 10);
|
||||
stream->samples_per_packet = 1;
|
||||
}
|
||||
|
||||
stream->caps = qtdemux_audio_caps(qtdemux,
|
||||
QTDEMUX_FOURCC_GET(stsd->data+16+4));
|
||||
QTDEMUX_FOURCC_GET(stsd->data+16+4), (QTDEMUX_GUINT32_GET(stsd->data) > offset) ? stsd->data + offset : NULL);
|
||||
g_print("caps %s\n",gst_caps_to_string(stream->caps));
|
||||
}else{
|
||||
g_print("unknown subtype\n");
|
||||
|
|
@ -1597,7 +1599,7 @@ static GstCaps *qtdemux_video_caps(GstQTDemux *qtdemux, guint32 fourcc, const gu
|
|||
}
|
||||
}
|
||||
|
||||
static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc)
|
||||
static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc, const guint8 *data)
|
||||
{
|
||||
switch(fourcc){
|
||||
case GST_MAKE_FOURCC('N','O','N','E'):
|
||||
|
|
@ -1685,8 +1687,15 @@ static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc)
|
|||
return gst_caps_from_string ("audio/mpeg, "
|
||||
"mpegversion = (int) 4");
|
||||
case GST_MAKE_FOURCC('Q','D','M','2'):
|
||||
/* QDesign music version 2 (no constant) */
|
||||
return gst_caps_from_string ("audio/x-qdm2");
|
||||
/* FIXME: QDesign music version 2 (no constant) */
|
||||
if (QTDEMUX_GUINT32_GET (data) <= 100) {
|
||||
gst_util_dump_mem ((guint8*)data, 100);
|
||||
return gst_caps_new_simple ("audio/x-qdm2",
|
||||
"framesize", G_TYPE_INT, QTDEMUX_GUINT32_GET (data + 52),
|
||||
"bitrate", G_TYPE_INT, QTDEMUX_GUINT32_GET (data + 40),
|
||||
"blocksize", G_TYPE_INT, QTDEMUX_GUINT32_GET (data + 44),
|
||||
NULL);
|
||||
}
|
||||
case GST_MAKE_FOURCC('q','t','v','r'):
|
||||
/* ? */
|
||||
case GST_MAKE_FOURCC('Q','D','M','C'):
|
||||
|
|
|
|||
Loading…
Reference in a new issue