diff -rNc gst-plugins.org/configure.ac gst-plugins/configure.ac
*** gst-plugins.org/configure.ac	2003/04/25 13:45:48
--- gst-plugins/configure.ac	2003/05/27 11:09:40
***************
*** 516,521 ****
--- 516,534 ----
    AM_PATH_ESD(0.2.12, HAVE_ESD=yes, HAVE_ESD=no)
    AS_SCRUB_INCLUDE(ESD_CFLAGS)
  ])
+ dnl
+ 
+ dnl **** Network Audio System ****
+ translit(dnm, m, l) AM_CONDITIONAL(USE_NAS, true)
+ GST_CHECK_FEATURE(NAS, [nas plug-ins], nassink, [
+   AC_PATH_XTRA
+   GST_CHECK_LIBHEADER(NAS, audio,
+                       AuOpenServer, $X_PRE_LIBS $X_LIBS -lXau $X_EXTRA_LIBS, 
+                       audio/audiolib.h, 
+                       NAS_LIBS="-laudio $X_PRE_LIBS $X_LIBS -lXau $X_EXTRA_LIBS")
+   AC_SUBST(NAS_LIBS)
+ ])
+ dnl
  
  dnl **** festival ****
  dnl translit(dnm, m, l) AM_CONDITIONAL(USE_FESTIVAL, true)
***************
*** 1091,1096 ****
--- 1104,1110 ----
  ext/dvdread/Makefile
  ext/dvdnav/Makefile
  ext/esd/Makefile
+ ext/nas/Makefile
  ext/ffmpeg/Makefile
  ext/flac/Makefile
  ext/gnomevfs/Makefile

diff -rNc gst-plugins.org/ext/Makefile.am gst-plugins/ext/Makefile.am
*** gst-plugins.org/ext/Makefile.am	2003/05/21 15:15:31
--- gst-plugins/ext/Makefile.am	2003/05/27 11:10:51
***************
*** 64,69 ****
--- 64,75 ----
  ESD_DIR=
  endif
  
+ if USE_NAS
+ NAS_DIR=nas
+ else
+ NAS_DIR=
+ endif
+ 
  ## if USE_FESTIVAL
  ## FESTIVAL_DIR=festival
  ## else
***************
*** 253,259 ****
  SUBDIRS=$(A52DEC_DIR) $(AALIB_DIR) $(ALSA_DIR) \
          $(ARTS_DIR) $(ARTSC_DIR) $(AUDIOFILE_DIR) \
  	$(AVIFILE_DIR) $(CDPARANOIA_DIR) \
! 	$(DVDREAD_DIR) $(DVDNAV_DIR) $(ESD_DIR) \
  	$(FFMPEG_DIR) $(FLAC_DIR) $(GNOMEVFS_DIR) $(GSM_DIR) \
  	$(HERMES_DIR) $(HTTP_DIR) $(JACK_DIR) $(JPEG_DIR) \
  	$(LADSPA_DIR) $(LAME_DIR) $(LCS_DIR) \
--- 259,265 ----
  SUBDIRS=$(A52DEC_DIR) $(AALIB_DIR) $(ALSA_DIR) \
          $(ARTS_DIR) $(ARTSC_DIR) $(AUDIOFILE_DIR) \
  	$(AVIFILE_DIR) $(CDPARANOIA_DIR) \
! 	$(DVDREAD_DIR) $(DVDNAV_DIR) $(ESD_DIR) $(NAS_DIR) \
  	$(FFMPEG_DIR) $(FLAC_DIR) $(GNOMEVFS_DIR) $(GSM_DIR) \
  	$(HERMES_DIR) $(HTTP_DIR) $(JACK_DIR) $(JPEG_DIR) \
  	$(LADSPA_DIR) $(LAME_DIR) $(LCS_DIR) \
diff -rNc gst-plugins.org/ext/nas/Makefile.am gst-plugins/ext/nas/Makefile.am
*** gst-plugins.org/ext/nas/Makefile.am	1970-01-01 01:00:00.000000000 +0100
--- gst-plugins/ext/nas/Makefile.am	2003-05-27 13:14:44.000000000 +0200
***************
*** 0 ****
--- 1,11 ----
+ plugindir = $(libdir)/gstreamer-@GST_MAJORMINOR@
+ 
+ plugin_LTLIBRARIES = libgstnassink.la
+ 
+ libgstnassink_la_SOURCES = nassink.c
+ libgstnassink_la_CFLAGS = $(GST_CFLAGS)
+ libgstnassink_la_LIBADD = $(NAS_LIBS) $(GST_LIBS)
+ libgstnassink_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
+ 
+ noinst_HEADERS = nassink.h
+ EXTRA_DIST = README
diff -rNc gst-plugins.org/ext/nas/README gst-plugins/ext/nas/README
*** gst-plugins.org/ext/nas/README	1970-01-01 01:00:00.000000000 +0100
--- gst-plugins/ext/nas/README	2003-05-27 13:14:46.000000000 +0200
***************
*** 0 ****
--- 1,11 ----
+ The nassink plugin
+ ==================
+ 
+ The nassink plugin is for outputting an audio stream to a Network Audio Server (NCD X/Terminal)
+ 
+ esdsink has arguments that it accepts:
+  - 'mute'      (boolean value)
+  - 'depth'     (sample depth in bits- defaults to 16)
+  - 'host'      (name of X/Terminal, default is $AUDIOSERVER or $DISPLAY)
+  - 'frequency' (integer value in Hz)
+  - 'channels'  (number of channels - 2 for stereo)
diff -rNc gst-plugins.org/ext/nas/nassink.c gst-plugins/ext/nas/nassink.c
*** gst-plugins.org/ext/nas/nassink.c	1970-01-01 01:00:00.000000000 +0100
--- gst-plugins/ext/nas/nassink.c	2003-05-27 13:14:47.000000000 +0200
***************
*** 0 ****
--- 1,718 ----
+ /* GStreamer
+  * Copyright (C) <2003> Laurent Vivier <Laurent.Vivier@bull.net>
+  *
+  * Based on esdsink.c:
+  * Copyright (C) <2001> Richard Boulton <richard-gst@tartarus.org>
+  *
+  * 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 <audio/audiolib.h>
+ #include <audio/soundlib.h>
+ #include "nassink.h"
+ 
+ #define NAS_SOUND_PORT_DURATION	(2)
+ 
+ /* elementfactory information */
+ static GstElementDetails nassink_details = {
+   "NAS sink",
+   "Sink/Audio",
+   "LGPL",
+   "Plays audio to a Network Audio Server",
+   VERSION,
+   "Laurent Vivier <Laurent.Vivier@bull.net>",
+   "(C) 2003",
+ };
+ 
+ /* Signals and args */
+ enum {
+   /* FILL ME */
+   LAST_SIGNAL
+ };
+ 
+ enum {
+   ARG_0,
+   ARG_MUTE,
+   ARG_DEPTH,
+   ARG_CHANNELS,
+   ARG_RATE,
+   ARG_HOST
+ };
+ 
+ GST_PAD_TEMPLATE_FACTORY (sink_factory,
+   ( "sink",					/* the name of the pads */
+     GST_PAD_SINK,				/* type of the pad */
+     GST_PAD_ALWAYS,			/* ALWAYS/SOMETIMES */
+     GST_CAPS_NEW (
+       "nassink_sink8",				/* the name of the caps */
+       "audio/raw",				/* the mime type of the caps */
+         /* Properties follow: */
+       ( "format",       GST_PROPS_STRING ("int"),
+           "law",        GST_PROPS_INT (0),
+           "endianness", GST_PROPS_INT (G_BYTE_ORDER),
+           "width",      GST_PROPS_INT (8),
+ 	  "depth",      GST_PROPS_INT (8),
+ 	  "rate",       GST_PROPS_INT_RANGE (8000, 96000),
+      	  "channels",   GST_PROPS_LIST_TYPE,
+ 				GST_PROPS_INT (1),
+ 				GST_PROPS_INT (2),
+ 			NULL,
+ 	  NULL
+       )
+     ),
+     GST_CAPS_NEW (
+       "nassink_sink16",				/* the name of the caps */
+       "audio/raw",				/* the mime type of the caps */
+         /* Properties follow: */
+       ( "format",       GST_PROPS_STRING ("int"),
+           "law",        GST_PROPS_INT (0),
+           "endianness", GST_PROPS_INT (G_BYTE_ORDER),
+           "signed",     GST_PROPS_BOOLEAN (TRUE),
+           "width",      GST_PROPS_INT (16),
+ 	  "depth",      GST_PROPS_INT (16),
+ 	  "rate",       GST_PROPS_INT_RANGE (8000, 96000),
+      	  "channels",   GST_PROPS_LIST_TYPE,
+ 				GST_PROPS_INT (1),
+ 				GST_PROPS_INT (2),
+ 			NULL,
+ 	  NULL
+       )
+     ),
+     NULL
+   )
+ )
+ 
+ static void			gst_nassink_class_init		(GstNassinkClass *klass);
+ static void			gst_nassink_init		(GstNassink *nassink);
+ 
+ static gboolean			gst_nassink_open_audio		(GstNassink *sink);
+ static void			gst_nassink_close_audio		(GstNassink *sink);
+ static GstElementStateReturn	gst_nassink_change_state	(GstElement *element);
+ static gboolean			gst_nassink_sync_parms		(GstNassink *nassink);
+ static GstPadLinkReturn		gst_nassink_sinkconnect		(GstPad *pad, GstCaps *caps);
+ 
+ static void			gst_nassink_chain		(GstPad *pad, GstBuffer *buf);
+ 
+ static void			gst_nassink_set_property	(GObject *object, guint prop_id, 
+ 								 const GValue *value, GParamSpec *pspec);
+ static void			gst_nassink_get_property	(GObject *object, guint prop_id, 
+ 								 GValue *value, GParamSpec *pspec);
+ 
+ static void			NAS_flush			(GstNassink *sink);
+ static void			NAS_sendData			(GstNassink *sink, AuUint32 numBytes);
+ static AuBool			NAS_EventHandler		(AuServer *aud, AuEvent *ev, AuEventHandlerRec *handler);
+ static AuDeviceID		NAS_getDevice			(AuServer* aud, int numTracks);
+ static int			NAS_allocBuffer			(GstNassink *sink);
+ static int			NAS_createFlow			(GstNassink *sink, unsigned char format, unsigned short rate, int numTracks);
+ 
+ #define GST_TYPE_NASSINK_DEPTHS (gst_nassink_depths_get_type())
+ static GType
+ gst_nassink_depths_get_type (void)
+ {
+   static GType nassink_depths_type = 0;
+   static GEnumValue nassink_depths[] = {
+     {8, "8", "8 Bits"},
+     {16, "16", "16 Bits"},
+     {0, NULL, NULL},
+   };
+   if (!nassink_depths_type) {
+     nassink_depths_type = g_enum_register_static("GstNassinkDepths", nassink_depths);
+   }
+   return nassink_depths_type;
+ }
+ 
+ #define GST_TYPE_NASSINK_CHANNELS (gst_nassink_channels_get_type())
+ static GType
+ gst_nassink_channels_get_type (void)
+ {
+   static GType nassink_channels_type = 0;
+   static GEnumValue nassink_channels[] = {
+     {1, "1", "Mono"},
+     {2, "2", "Stereo"},
+     {0, NULL, NULL},
+   };
+   if (!nassink_channels_type) {
+     nassink_channels_type = g_enum_register_static("GstNassinkChannels", nassink_channels);
+   }
+   return nassink_channels_type;
+ }
+ 
+ 
+ static GstElementClass *parent_class = NULL;
+ /*static guint gst_nassink_signals[LAST_SIGNAL] = { 0 }; */
+ 
+ GType
+ gst_nassink_get_type (void)
+ {
+   static GType nassink_type = 0;
+ 
+   if (!nassink_type) {
+     static const GTypeInfo nassink_info = {
+       sizeof(GstNassinkClass),      NULL,
+       NULL,
+       (GClassInitFunc)gst_nassink_class_init,
+       NULL,
+       NULL,
+       sizeof(GstNassink),
+       0,
+       (GInstanceInitFunc)gst_nassink_init,
+     };
+     nassink_type = g_type_register_static(GST_TYPE_ELEMENT, "GstNassink", &nassink_info, 0);
+   }
+ 
+   return nassink_type;
+ }
+ 
+ static void
+ gst_nassink_class_init (GstNassinkClass *klass)
+ {
+   GObjectClass *gobject_class;
+   GstElementClass *gstelement_class;
+ 
+   gobject_class = (GObjectClass*)klass;
+   gstelement_class = (GstElementClass*)klass;
+ 
+   if (parent_class == NULL)
+     parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
+ 
+   gobject_class->set_property = gst_nassink_set_property;
+   gobject_class->get_property = gst_nassink_get_property;
+ 
+   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_MUTE,
+     g_param_spec_boolean("mute","mute","mute",
+                          TRUE,G_PARAM_READWRITE)); /* CHECKME */
+   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEPTH,
+     g_param_spec_enum("depth","depth","depth",
+                       GST_TYPE_NASSINK_DEPTHS,16,G_PARAM_READWRITE)); /* CHECKME! */
+   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CHANNELS,
+     g_param_spec_enum("channels","channels","channels",
+                       GST_TYPE_NASSINK_CHANNELS,2,G_PARAM_READWRITE)); /* CHECKME! */
+   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_RATE,
+     g_param_spec_int("frequency","frequency","frequency",
+                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
+   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_HOST,
+     g_param_spec_string("host","host","host",
+                         NULL, G_PARAM_READWRITE)); /* CHECKME */
+ 
+   gstelement_class->change_state = gst_nassink_change_state;
+ }
+ 
+ static void
+ gst_nassink_init(GstNassink *nassink)
+ {
+   nassink->sinkpad = gst_pad_new_from_template (
+ 		  GST_PAD_TEMPLATE_GET (sink_factory), "sink");
+   gst_element_add_pad(GST_ELEMENT(nassink), nassink->sinkpad);
+   gst_pad_set_chain_function(nassink->sinkpad, GST_DEBUG_FUNCPTR(gst_nassink_chain));
+   gst_pad_set_link_function(nassink->sinkpad, gst_nassink_sinkconnect);
+ 
+   nassink->mute = FALSE;
+   nassink->depth = 16;
+   nassink->tracks = 2;
+   nassink->rate = 44100;
+   nassink->host = g_strdup (getenv("AUDIOSERVER"));
+   if (nassink->host == NULL)
+     nassink->host = g_strdup (getenv("DISPLAY"));
+ 
+   nassink->audio = NULL;
+   nassink->flow = AuNone;
+   nassink->size = 0;
+   nassink->pos = 0;
+   nassink->buf = NULL;
+ }
+ 
+ static gboolean
+ gst_nassink_sync_parms (GstNassink *nassink)
+ {
+   gint ret;
+   unsigned char format;
+   g_return_val_if_fail (nassink != NULL, FALSE);
+   g_return_val_if_fail (GST_IS_NASSINK (nassink), FALSE);
+ 
+   if (nassink->audio == NULL) return TRUE;
+ 
+   if (nassink->flow != AuNone)
+   {
+     while (nassink->pos && nassink->buf)
+       NAS_flush(nassink);
+     AuStopFlow( nassink->audio, nassink->flow, NULL);
+     AuReleaseScratchFlow(nassink->audio, nassink->flow, NULL);
+     nassink->flow == AuNone;
+   }
+ 
+   if (nassink->depth == 16)
+ #if G_BYTE_ORDER == G_BIG_ENDIAN
+     format = AuFormatLinearSigned16MSB;
+ #else
+     format = AuFormatLinearSigned16LSB;
+ #endif
+   else
+     format = AuFormatLinearUnsigned8;
+ 
+   ret = NAS_createFlow(nassink, format, nassink->rate, nassink->tracks);
+ 
+   return ret >= 0;
+ }
+ 
+ static GstPadLinkReturn
+ gst_nassink_sinkconnect (GstPad *pad, GstCaps *caps)
+ {
+   gint ret;
+   GstNassink *nassink;
+   unsigned char format;
+ 
+   nassink = GST_NASSINK (gst_pad_get_parent (pad));
+ 
+   if (!GST_CAPS_IS_FIXED (caps))
+       return GST_PAD_LINK_DELAYED;
+ 
+   gst_caps_get_int (caps, "depth", &nassink->depth);
+   gst_caps_get_int (caps, "channels", &nassink->tracks);
+   gst_caps_get_int (caps, "rate", &nassink->rate);
+ 
+   if (!gst_nassink_sync_parms(nassink))
+     return GST_PAD_LINK_REFUSED;
+ 
+   return GST_PAD_LINK_OK;
+ }
+ 
+ static void
+ gst_nassink_chain (GstPad *pad, GstBuffer *buf)
+ {
+   int pos = 0;
+   int remaining;
+   int available;
+   GstNassink *nassink;
+ 
+   g_return_if_fail(pad != NULL);
+   g_return_if_fail(GST_IS_PAD(pad));
+   g_return_if_fail(buf != NULL);
+ 
+   nassink = GST_NASSINK (gst_pad_get_parent (pad));
+ 
+   g_return_if_fail(nassink->buf != NULL);
+ 
+   if (GST_BUFFER_DATA (buf) != NULL) {
+     if (!nassink->mute && nassink->audio != NULL) {
+       GST_DEBUG (0, "nassink: server=0x%x data=%p size=%d",
+ 		 nassink->audio, GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf));
+ 
+       remaining = GST_BUFFER_SIZE (buf);
+       while ((nassink->flow != AuNone) && ( remaining > 0)) {
+ 
+         /* number of bytes we can copy to buffer */
+      
+         available = remaining > nassink->size - nassink->pos ?
+ 		    nassink->size - nassink->pos : remaining;
+ 
+ 	/* fill the buffer */
+ 
+ 	memcpy (nassink->buf + nassink->pos, GST_BUFFER_DATA (buf) + pos, available);
+ 
+ 	nassink->pos += available;
+ 	pos += available;
+ 
+ 	remaining -= available;
+ 
+ 	/* if we have more bytes, need to flush the buffer */
+ 
+ 	if (remaining > 0) {
+ 	  while ((nassink->flow != AuNone) && (nassink->pos == nassink->size)) {
+ 	    NAS_flush(nassink);
+ 	  }
+ 	}
+       }
+ 
+       /* give some time to event handler */
+ 
+       AuSync(nassink->audio, AuFalse);
+ 
+     }
+   }
+   gst_buffer_unref (buf);
+ }
+ 
+ static void
+ gst_nassink_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+ {
+   GstNassink *nassink;
+ 
+   /* it's not null if we got it, but it might not be ours */
+   g_return_if_fail(GST_IS_NASSINK(object));
+   nassink = GST_NASSINK(object);
+ 
+   switch (prop_id) {
+   case ARG_MUTE:
+     nassink->mute = g_value_get_boolean (value);
+     break;
+   case ARG_DEPTH:
+     nassink->depth = g_value_get_enum (value);
+     gst_nassink_sync_parms (nassink);
+     break;
+   case ARG_CHANNELS:
+     nassink->tracks = g_value_get_enum (value);
+     gst_nassink_sync_parms (nassink);
+     break;
+   case ARG_RATE:
+     nassink->rate = g_value_get_int (value);
+     gst_nassink_sync_parms (nassink);
+     break;
+   case ARG_HOST:
+     if (nassink->host != NULL) g_free(nassink->host);
+     if (g_value_get_string (value) == NULL)
+         nassink->host = NULL;
+     else
+         nassink->host = g_strdup (g_value_get_string (value));
+     break;
+   default:
+     break;
+   }
+ }
+ 
+ static void
+ gst_nassink_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+ {
+   GstNassink *nassink;
+ 
+   g_return_if_fail(GST_IS_NASSINK(object));
+ 
+   nassink = GST_NASSINK(object);
+ 
+   switch (prop_id) {
+   case ARG_MUTE:
+     g_value_set_boolean (value, nassink->mute);
+     break;
+   case ARG_DEPTH:
+     g_value_set_enum (value, nassink->depth);
+     break;
+   case ARG_CHANNELS:
+     g_value_set_enum (value, nassink->tracks);
+     break;
+   case ARG_RATE:
+     g_value_set_int (value, nassink->rate);
+     break;
+   case ARG_HOST:
+     g_value_set_string (value, nassink->host);
+     break;
+   default:
+     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+     break;
+   }
+ }
+ 
+ static gboolean
+ plugin_init (GModule *module, GstPlugin *plugin)
+ {
+   GstElementFactory *factory;
+ 
+   factory = gst_element_factory_new("nassink", GST_TYPE_NASSINK,
+ 				   &nassink_details);
+   g_return_val_if_fail(factory != NULL, FALSE);
+ 
+   gst_element_factory_add_pad_template(factory, GST_PAD_TEMPLATE_GET (sink_factory));
+ 
+   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+ 
+   return TRUE;
+ }
+ 
+ GstPluginDesc plugin_desc = {
+   GST_VERSION_MAJOR,
+   GST_VERSION_MINOR,
+   "nassink",
+   plugin_init
+ };
+ 
+ static gboolean
+ gst_nassink_open_audio (GstNassink *sink)
+ {
+   int i;
+ 
+   /* Open Server */
+ 
+   sink->audio = AuOpenServer(sink->host, 0, NULL, 0, NULL, NULL);
+   if (sink->audio == NULL)
+     return FALSE;
+ 
+   sink->flow = AuNone;
+   sink->size = 0;
+   sink->pos = 0;
+   sink->buf = NULL;
+ 
+   /* Start a flow */
+ 
+   GST_FLAG_SET (sink, GST_NASSINK_OPEN);
+ 
+   return TRUE;
+ }
+ 
+ static void
+ gst_nassink_close_audio (GstNassink *sink)
+ {
+   if (sink->audio == NULL) return;
+ 
+   if (sink->flow != AuNone) {
+     while (sink->pos && sink->buf) {
+       NAS_flush(sink);
+     }
+ 
+     AuStopFlow( sink->audio, sink->flow, NULL);
+     AuReleaseScratchFlow(sink->audio, sink->flow, NULL);
+     sink->flow == AuNone;
+   }
+ 
+   if (sink->buf != NULL)
+   {
+     free(sink->buf);
+     sink->buf = NULL;
+   }
+ 
+   AuCloseServer(sink->audio);
+   sink->audio = NULL;
+ 
+   GST_FLAG_UNSET (sink, GST_NASSINK_OPEN);
+ 
+   GST_DEBUG (0, "nassink: closed sound device");
+ }
+ 
+ static GstElementStateReturn
+ gst_nassink_change_state (GstElement *element)
+ {
+   GstNassink *nassink;
+   g_return_val_if_fail (GST_IS_NASSINK (element), FALSE);
+ 
+   nassink = GST_NASSINK (element);
+ 
+   switch (GST_STATE_PENDING (element)) {
+   case GST_STATE_NULL:
+     if (GST_FLAG_IS_SET (element, GST_NASSINK_OPEN))
+       gst_nassink_close_audio (nassink);
+     break;
+ 
+   case GST_STATE_READY:
+     if (!GST_FLAG_IS_SET (element, GST_NASSINK_OPEN))
+       gst_nassink_open_audio (nassink);
+     break;
+ 
+   case GST_STATE_PAUSED:
+     while (nassink->pos && nassink->buf)
+       NAS_flush(nassink);
+     break;
+ 
+   case GST_STATE_PLAYING:
+     break;
+   }
+ 
+   if (GST_ELEMENT_CLASS (parent_class)->change_state)
+     return GST_ELEMENT_CLASS (parent_class)->change_state (element);
+ 
+   return GST_STATE_SUCCESS;
+ }
+ 
+ static void
+ NAS_flush(GstNassink *sink)
+ {
+   AuEvent ev;
+ 
+   AuNextEvent(sink->audio, AuTrue, &ev);
+   AuDispatchEvent(sink->audio, &ev);
+ }
+ 
+ static void
+ NAS_sendData(GstNassink *sink, AuUint32 numBytes)
+ {
+   if (numBytes < (sink->pos)) {
+ 
+     AuWriteElement(sink->audio, sink->flow, 0,
+ 		   numBytes, sink->buf, AuFalse, NULL);
+ 
+     memmove(sink->buf, sink->buf + numBytes,
+ 	    sink->pos - numBytes);
+ 
+     sink->pos = sink->pos - numBytes;
+ 
+   } else
+   {
+     AuWriteElement(sink->audio, sink->flow, 0,
+ 		   sink->pos, sink->buf,
+ 		   (numBytes > sink->pos), NULL);
+     sink->pos = 0;
+   }
+ }
+ 
+ static AuBool
+ NAS_EventHandler(AuServer *aud, AuEvent *ev, AuEventHandlerRec *handler)
+ {
+   GstNassink *sink = (GstNassink *)handler->data;
+   AuElementNotifyEvent *notify;
+ 
+   switch (ev->type) {
+ 
+   case AuEventTypeElementNotify:
+ 
+     notify = (AuElementNotifyEvent *) ev;
+ 
+     switch(notify->kind) {
+ 
+     case AuElementNotifyKindLowWater:
+       NAS_sendData(sink, notify->num_bytes);
+       break;
+ 
+     case AuElementNotifyKindState:
+ 
+       switch(notify->cur_state) {
+ 
+       case AuStateStop:
+ 	 
+ 	if (sink->flow != AuNone) {
+ 	  if (notify->reason == AuReasonEOF)
+ 	    AuStopFlow(handler->aud, sink->flow, NULL);
+ 	  AuReleaseScratchFlow(handler->aud, sink->flow, NULL);
+ 	  sink->flow = AuNone;
+ 	}
+ 	AuUnregisterEventHandler(handler->aud, handler);
+         break;
+ 
+       case AuStatePause:
+ 
+         switch(notify->reason) {
+ 	case AuReasonUnderrun:
+ 	case AuReasonOverrun:
+ 	case AuReasonEOF:
+ 	case AuReasonWatermark:
+ 
+ 	  NAS_sendData(sink, notify->num_bytes);
+ 
+ 	  break;
+ 
+ 	case AuReasonHardware:
+ 
+ 	  if (AuSoundRestartHardwarePauses)
+ 	    AuStartFlow(handler->aud, sink->flow, NULL);
+ 	  else
+ 	    AuStopFlow(handler->aud, sink->flow, NULL);
+ 
+ 	  break;
+ 	}
+         break;
+       }
+       break;
+     }
+     break;
+   }
+ }
+ 
+ static AuDeviceID
+ NAS_getDevice(AuServer* aud, int numTracks)
+ {
+   int i;
+ 
+   for (i = 0; i < AuServerNumDevices(aud); i++) {
+     if ( (AuDeviceKind(AuServerDevice(aud, i))
+ 				== AuComponentKindPhysicalOutput) &&
+ 	 (AuDeviceNumTracks(AuServerDevice(aud, i)) == numTracks )) {
+ 
+       return AuDeviceIdentifier(AuServerDevice(aud, i));
+ 
+     }
+   }
+ }
+ 
+ static int
+ NAS_allocBuffer(GstNassink *sink)
+ {
+   if (sink->buf != NULL) {
+     free(sink->buf);
+   }
+ 
+   sink->buf = (char *) malloc(sink->size);
+   if (sink->buf == NULL) {
+ 
+     return -1;
+ 
+   }
+ 
+   sink->pos = 0;
+ 
+   return 0;
+ }
+ 
+ static int
+ NAS_createFlow(GstNassink *sink, unsigned char format, unsigned short rate, int numTracks)
+ {
+   AuDeviceID device;
+   AuElement elements[2];
+   AuUint32 buf_samples;
+ 
+   device = NAS_getDevice(sink->audio, numTracks);
+   if (device == AuNone) {
+     return -1;
+   }
+ 
+   sink->flow = AuGetScratchFlow(sink->audio, NULL);
+   if (sink->flow == 0) {
+     return -1;
+   }
+ 
+   buf_samples = rate * NAS_SOUND_PORT_DURATION;
+ 
+   AuMakeElementImportClient( &elements[0],		/* element */
+                              rate,			/* rate */
+                              format,			/* format */
+                              numTracks,			/* number of tracks */
+                              AuTrue,			/* discart */
+                              buf_samples,		/* max samples */
+                              (AuUint32) (buf_samples / 100
+                                       * AuSoundPortLowWaterMark),
+ 							/* low water mark */
+                              0,				/* num actions */
+                              NULL);
+ 
+   AuMakeElementExportDevice( &elements[1],		/* element */
+                              0,				/* input */
+                              device,			/* device */
+                              rate,			/* rate */
+                              AuUnlimitedSamples,	/* num samples */
+                              0,				/* num actions */
+                              NULL);			/* actions */
+ 
+   AuSetElements( sink->audio,				/* server */
+                  sink->flow,				/* flow ID */
+                  AuTrue,				/* clocked */
+                  2,					/* num elements */
+                  elements,				/* elements */
+                  NULL);
+ 
+   AuRegisterEventHandler( sink->audio,			/* server */
+                           AuEventHandlerIDMask,		/* value mask */
+                           0,				/* type */
+                           sink->flow,			/* flow ID */
+                           NAS_EventHandler,		/* callback */
+                           (AuPointer)sink);		/* data */
+ 
+   sink->size = buf_samples * numTracks * AuSizeofFormat(format);
+ 
+   if (NAS_allocBuffer(sink) < 0) {
+ 
+     AuReleaseScratchFlow(sink->audio, sink->flow, NULL);
+ 
+     return -1;
+   }
+ 
+   AuStartFlow(sink->audio, sink->flow, NULL);
+ 
+   return 0;
+ }
diff -rNc gst-plugins.org/ext/nas/nassink.h gst-plugins/ext/nas/nassink.h
*** gst-plugins.org/ext/nas/nassink.h	1970-01-01 01:00:00.000000000 +0100
--- gst-plugins/ext/nas/nassink.h	2003-05-27 13:14:47.000000000 +0200
***************
*** 0 ****
--- 1,88 ----
+ /* GStreamer
+  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
+  *
+  * 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_NASSINK_H__
+ #define __GST_NASSINK_H__
+ 
+ #include <gst/gst.h>
+ 
+ #ifdef __cplusplus
+ extern "C" {
+ #endif /* __cplusplus */
+ 
+ 
+ #define GST_TYPE_NASSINK \
+   (gst_nassink_get_type())
+ #define GST_NASSINK(obj) \
+   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_NASSINK,GstNassink))
+ #define GST_NASSINK_CLASS(klass) \
+   (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_NASSINK,GstNassink))
+ #define GST_IS_NASSINK(obj) \
+   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_NASSINK))
+ #define GST_IS_NASSINK_CLASS(obj) \
+   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_NASSINK))
+ 
+ typedef enum {
+   GST_NASSINK_OPEN            = GST_ELEMENT_FLAG_LAST,
+   GST_NASSINK_FLAG_LAST       = GST_ELEMENT_FLAG_LAST+2
+ } GstNasSinkFlags;
+ 
+ typedef struct _GstNassink GstNassink;
+ typedef struct _GstNassinkClass GstNassinkClass;
+ 
+ struct _GstNassink {
+   GstElement element;
+ 
+   GstPad *sinkpad;
+ 
+   /* instance properties */
+ 
+   gboolean mute;
+   gint depth;
+   gint tracks;
+   gint rate;
+   gchar* host;
+ 
+   /* Server info */
+ 
+   AuServer *audio;
+   AuFlowID flow;
+ 
+   /* buffer */
+ 
+   AuUint32 size;
+   AuUint32 pos;
+ 
+   char *buf;
+ };
+ 
+ struct _GstNassinkClass {
+   GstElementClass parent_class;
+ };
+ 
+ GType gst_nassink_get_type(void);
+ 
+ 
+ #ifdef __cplusplus
+ }
+ #endif /* __cplusplus */
+ 
+ 
+ #endif /* __GST_NASSINK_H__ */