[gst-devel] mixer track/device naming (again)

Leif Johnson leif at ambient.2y.net
Mon Nov 3 14:02:16 CET 2003


Hey Ronald -

I suggested the `track' name for a mixer element after seeing programs
like Pro Tools, Logic, and Reason : all are pro audio software that use
GUI rows of audio `tracks' to represent things like drum loops, guitar
riffs, vocal or trumpet pieces, etc. Tracks can have any number of
channels (e.g. mono or stereo, etc). Video mixing and sequencing
programs (e.g. Final Cut on Mac OSX) are similar, representing different
video streams as tracks.

It seems like we have two different mixer concepts going on here. One,
described above, is a software mixer that mixes one or more tracks (with
the same props : channels, sample rate, int/float, etc.). I'd use the
`mixmatrix' or `adder' GStreamer elements for this one. The other, which
you implemented for gst-mixer, is a hardware mixer that sets the output
levels and properties of various sound card devices. We're using the
various sink elements for this one. Both are important devices.

But in the first concept, the number of GStreamer pads on an element is
the same as the number of tracks that it handles. In the second concept,
though, the number of pads on the element has almost nothing to do with
the number of devices in the physical output card ; for example, if I
use an alsasink with two pads, my sound card automatically sends both
signals through the PCM output device. This came up while reading the
alsasink code, so I wanted to discuss.

Do you think we need two separate interfaces for these ? At the very
least, the track concept is a bit confusing for me in the context of
this hardware level-setting concept. I'd like to rename `track' to
`device' ... if you think this is a good idea, there are patches
attached for the plugins and gst-mixer. I haven't been able to see if
they compile because ffmpeg isn't compiling for me atm (anyone know
where I can get ffmpeg/libavformat/flvdec.c ?).

leif

make[5]: *** No rule to make target `ffmpeg/libavformat/flvdec.c', needed by `libavformat_la-flvdec.lo'. Stop.
make[5]: Leaving directory `/home/leif/src/gst-plugins/gst-libs/ext/ffmpeg'

--
Leif Morgan Johnson : http://ambient.2y.net/leif/
-------------- next part --------------
? ChangeLog
? aclocal.m4
? autom4te.cache
? autoregen.sh
? compile
? config.guess
? config.h
? config.h.in
? config.log
? config.status
? config.sub
? configure
? depcomp
? gst-libs
? gst-mixer.spec
? install-sh
? libtool
? ltmain.sh
? missing
? mkinstalldirs
? stamp-h.in
? stamp-h1
? src/gst-mixer
Index: src/mixer.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-sandbox/gst-mixer/src/mixer.c,v
retrieving revision 1.9
diff -u -r1.9 mixer.c
--- src/mixer.c	14 Oct 2003 19:05:32 -0000	1.9
+++ src/mixer.c	3 Nov 2003 21:51:56 -0000
@@ -31,7 +31,7 @@
 
 typedef struct _MyMixerControls {
   GstMixer *mixer;
-  GstMixerTrack *track;
+  GstMixerDevice *device;
   GList *adjustments;
   GtkWidget *lock, *mute, *record;
   gboolean locked;
@@ -84,7 +84,7 @@
     }
   }
 
-  gst_mixer_set_volume (ctrl->mixer, ctrl->track, volumes);
+  gst_mixer_set_volume (ctrl->mixer, ctrl->device, volumes);
 
   g_free (volumes);
   ctrl->locked = FALSE;
@@ -123,7 +123,7 @@
 		 gpointer   data)
 {
   MyMixerControls *ctrl = (MyMixerControls *) data;
-  gst_mixer_set_mute (ctrl->mixer, ctrl->track,
+  gst_mixer_set_mute (ctrl->mixer, ctrl->device,
 		      gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
 }
 
@@ -132,15 +132,15 @@
 		   gpointer   data)
 {
   MyMixerControls *ctrl = (MyMixerControls *) data;
-  gst_mixer_set_record (ctrl->mixer, ctrl->track,
+  gst_mixer_set_record (ctrl->mixer, ctrl->device,
 		        gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)));
 }
 
 static void
-create_track_widget (GstMixer      *mixer,
+create_device_widget (GstMixer      *mixer,
 		     GtkWidget     *table,
 		     gint           column_pos,
-		     GstMixerTrack *track)
+		     GstMixerDevice *device)
 {
   GtkWidget *label, *slider, *button, *image;
   GtkObject *adj;
@@ -149,16 +149,16 @@
   MyMixerControls *ctrl = g_new0 (MyMixerControls, 1);
   gchar *str = NULL;
 
-  volumes = g_malloc (sizeof (gint) * track->num_channels);
+  volumes = g_malloc (sizeof (gint) * device->num_channels);
 
   ctrl->mixer = mixer;
-  ctrl->track = track;
+  ctrl->device = device;
   ctrl->locked = FALSE;
 
   /* image (optional) */
   for (i = 0; str == NULL && pix[i].label != NULL; i++) {
     /* we dup the string to make the comparison case-insensitive */
-    gchar *label_l = g_strdup (track->label),
+    gchar *label_l = g_strdup (device->label),
 	  *needle_l = g_strdup (pix[i].label);
     gint pos;
 
@@ -179,24 +179,24 @@
     if ((image = gtk_image_new_from_stock (str, GTK_ICON_SIZE_MENU)) != NULL) {
       gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.5);
       gtk_table_attach_defaults (GTK_TABLE (table), image,
-				 column_pos, column_pos + track->num_channels,
+				 column_pos, column_pos + device->num_channels,
 				 0, 1);
     }
   }
 
   /* label */
-  label = gtk_label_new (track->label);
+  label = gtk_label_new (device->label);
   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
   gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
   gtk_table_attach_defaults (GTK_TABLE (table), label,
-			     column_pos, column_pos + track->num_channels,
+			     column_pos, column_pos + device->num_channels,
 			     1, 2);
 
-  /* now sliders for each of the tracks */
-  gst_mixer_get_volume (mixer, track, volumes);
-  for (i = 0; i < track->num_channels; i++) {
+  /* now sliders for each of the devices */
+  gst_mixer_get_volume (mixer, device, volumes);
+  for (i = 0; i < device->num_channels; i++) {
     adj = gtk_adjustment_new (volumes[i],
-			      track->min_volume, track->max_volume,
+			      device->min_volume, device->max_volume,
 			      1.0, 1.0, 0.0);
     adjlist = g_list_append (adjlist, (gpointer) adj);
     g_signal_connect (G_OBJECT (adj), "value_changed",
@@ -213,10 +213,10 @@
   ctrl->adjustments = adjlist;
 
   /* buttons (lock, mute, rec) */
-  if (track->num_channels > 1) {
+  if (device->num_channels > 1) {
     button = gtk_check_button_new_with_label (_("Lock"));
     gtk_table_attach_defaults (GTK_TABLE (table), button,
-			       column_pos, column_pos + track->num_channels,
+			       column_pos, column_pos + device->num_channels,
 			       3, 4);
     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
     ctrl->lock = button;
@@ -226,23 +226,23 @@
 
   button = gtk_check_button_new_with_label (_("Mute"));
   gtk_table_attach_defaults (GTK_TABLE (table), button,
-			     column_pos, column_pos + track->num_channels,
+			     column_pos, column_pos + device->num_channels,
 			     4, 5);
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-				GST_MIXER_TRACK_HAS_FLAG (track,
-						GST_MIXER_TRACK_MUTE));
+				GST_MIXER_DEVICE_HAS_FLAG (device,
+						GST_MIXER_DEVICE_MUTE));
   g_signal_connect (G_OBJECT (button), "toggled",
 		    G_CALLBACK (cb_mute_toggled), (gpointer) ctrl);
   ctrl->mute = button;
 
-  if (GST_MIXER_TRACK_HAS_FLAG (track, GST_MIXER_TRACK_INPUT)) {
+  if (GST_MIXER_DEVICE_HAS_FLAG (device, GST_MIXER_DEVICE_INPUT)) {
     button = gtk_check_button_new_with_label (_("Rec."));
     gtk_table_attach_defaults (GTK_TABLE (table), button,
-			       column_pos, column_pos + track->num_channels,
+			       column_pos, column_pos + device->num_channels,
 			       5, 6);
     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
-				  GST_MIXER_TRACK_HAS_FLAG (track,
-						GST_MIXER_TRACK_RECORD));
+				  GST_MIXER_DEVICE_HAS_FLAG (device,
+						GST_MIXER_DEVICE_RECORD));
     g_signal_connect (G_OBJECT (button), "toggled",
 		      G_CALLBACK (cb_record_toggled), (gpointer) ctrl);
     ctrl->record = button;
@@ -256,17 +256,17 @@
 {
   GtkWidget *table;
   gint tablepos = 0;
-  const GList *tracks;
+  const GList *devices;
 
-  /* count number of tracks */
-  tracks = gst_mixer_list_tracks (mixer);
-  for ( ; tracks != NULL; tracks = tracks->next) {
-    tablepos += ((GstMixerTrack *) tracks->data)->num_channels;
-    if (tracks->next != NULL)
+  /* count number of devices */
+  devices = gst_mixer_list_devices (mixer);
+  for ( ; devices != NULL; devices = devices->next) {
+    tablepos += ((GstMixerDevice *) devices->data)->num_channels;
+    if (devices->next != NULL)
       tablepos++;
   }
 
-  /* create table for all single tracks */
+  /* create table for all single devices */
   table = gtk_table_new (6, tablepos, FALSE);
   gtk_container_set_border_width (GTK_CONTAINER (table), 4);
   gtk_table_set_row_spacings (GTK_TABLE (table), 2);
@@ -274,12 +274,12 @@
 
   /* add each */
   tablepos = 0;
-  tracks = gst_mixer_list_tracks (mixer);
-  for ( ; tracks != NULL; tracks = tracks->next) {
-    create_track_widget (mixer, table, tablepos,
-			 (GstMixerTrack *) tracks->data);
-    tablepos += ((GstMixerTrack *) tracks->data)->num_channels;
-    if (tracks->next != NULL) {
+  devices = gst_mixer_list_devices (mixer);
+  for ( ; devices != NULL; devices = devices->next) {
+    create_device_widget (mixer, table, tablepos,
+			 (GstMixerDevice *) devices->data);
+    tablepos += ((GstMixerDevice *) devices->data)->num_channels;
+    if (devices->next != NULL) {
       GtkWidget *sep = gtk_vseparator_new ();
       gtk_table_attach_defaults (GTK_TABLE (table), sep,
 				 tablepos, tablepos+1, 0, 6);
@@ -337,7 +337,7 @@
     }
     label = gtk_label_new (name);
 
-    /* add new notebook page + keep track */
+    /* add new notebook page + keep device */
     gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);
     collection = g_list_append (collection, element);
     num++;
-------------- next part --------------
Index: sys/oss/gstosselement.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/sys/oss/gstosselement.c,v
retrieving revision 1.9
diff -u -r1.9 gstosselement.c
--- sys/oss/gstosselement.c	31 Oct 2003 20:03:29 -0000	1.9
+++ sys/oss/gstosselement.c	3 Nov 2003 21:46:06 -0000
@@ -138,7 +138,7 @@
   oss->mixer_dev = g_strdup ("/dev/mixer");
   oss->fd = -1;
   oss->mixer_fd = -1;
-  oss->tracklist = NULL;
+  oss->devicelist = NULL;
   oss->device_name = NULL;
 
   gst_osselement_reset (oss);
Index: sys/oss/gstosselement.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/sys/oss/gstosselement.h,v
retrieving revision 1.4
diff -u -r1.4 gstosselement.h
--- sys/oss/gstosselement.h	31 Oct 2003 20:03:29 -0000	1.4
+++ sys/oss/gstosselement.h	3 Nov 2003 21:46:06 -0000
@@ -76,7 +76,7 @@
   gint		 rate;
 
   /* mixer stuff */
-  GList		*tracklist;
+  GList		*devicelist;
   guint32	 stereomask,
 		 recdevs,
 		 recmask,
Index: sys/oss/gstossmixer.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/sys/oss/gstossmixer.c,v
retrieving revision 1.6
diff -u -r1.6 gstossmixer.c
--- sys/oss/gstossmixer.c	14 Oct 2003 10:11:14 -0000	1.6
+++ sys/oss/gstossmixer.c	3 Nov 2003 21:46:06 -0000
@@ -37,30 +37,30 @@
 #define MASK_BIT_IS_SET(mask, bit) \
   (mask & (1 << bit))
 
-static void	gst_ossmixer_track_class_init (GstOssMixerTrackClass *klass);
-static void	gst_ossmixer_track_init    (GstOssMixerTrack *track);
+static void	gst_ossmixer_device_class_init (GstOssMixerDeviceClass *klass);
+static void	gst_ossmixer_device_init    (GstOssMixerDevice *device);
 
 static gboolean	gst_ossmixer_supported	   (GstInterface   *iface,
 					    GType           iface_type);
 static const GList *
-		gst_ossmixer_list_tracks   (GstMixer       *ossmixer);
+		gst_ossmixer_list_devices   (GstMixer       *ossmixer);
 
 static void	gst_ossmixer_set_volume	   (GstMixer       *ossmixer,
-					    GstMixerTrack  *track,
+					    GstMixerDevice  *device,
 					    gint           *volumes);
 static void	gst_ossmixer_get_volume	   (GstMixer       *ossmixer,
-					    GstMixerTrack  *track,
+					    GstMixerDevice  *device,
 					    gint           *volumes);
 
 static void	gst_ossmixer_set_record	   (GstMixer       *ossmixer,
-					    GstMixerTrack  *track,
+					    GstMixerDevice  *device,
 					    gboolean        record);
 static void	gst_ossmixer_set_mute	   (GstMixer       *ossmixer,
-					    GstMixerTrack  *track,
+					    GstMixerDevice  *device,
 					    gboolean        mute);
 
 static const gchar **labels = NULL;
-static GstMixerTrackClass *parent_class = NULL;
+static GstMixerDeviceClass *parent_class = NULL;
 
 /* three functions: firstly, OSS has the nasty habit of inserting
  * spaces in the labels, we want to get rid of them. Secondly,
@@ -126,80 +126,80 @@
 }
 
 GType
-gst_ossmixer_track_get_type (void)
+gst_ossmixer_device_get_type (void)
 {
-  static GType gst_ossmixer_track_type = 0;
+  static GType gst_ossmixer_device_type = 0;
 
-  if (!gst_ossmixer_track_type) {
-    static const GTypeInfo ossmixer_track_info = {
-      sizeof (GstOssMixerTrackClass),
+  if (!gst_ossmixer_device_type) {
+    static const GTypeInfo ossmixer_device_info = {
+      sizeof (GstOssMixerDeviceClass),
       NULL,
       NULL,
-      (GClassInitFunc) gst_ossmixer_track_class_init,
+      (GClassInitFunc) gst_ossmixer_device_class_init,
       NULL,
       NULL,
-      sizeof (GstOssMixerTrack),
+      sizeof (GstOssMixerDevice),
       0,
-      (GInstanceInitFunc) gst_ossmixer_track_init,
+      (GInstanceInitFunc) gst_ossmixer_device_init,
       NULL
     };
 
-    gst_ossmixer_track_type =
-	g_type_register_static (GST_TYPE_MIXER_TRACK,
-				"GstOssMixerTrack",
-				&ossmixer_track_info, 0);
+    gst_ossmixer_device_type =
+	g_type_register_static (GST_TYPE_MIXER_DEVICE,
+				"GstOssMixerDevice",
+				&ossmixer_device_info, 0);
   }
 
-  return gst_ossmixer_track_type;
+  return gst_ossmixer_device_type;
 }
 
 static void
-gst_ossmixer_track_class_init (GstOssMixerTrackClass *klass)
+gst_ossmixer_device_class_init (GstOssMixerDeviceClass *klass)
 {
-  parent_class = g_type_class_ref (GST_TYPE_MIXER_TRACK);
+  parent_class = g_type_class_ref (GST_TYPE_MIXER_DEVICE);
 }
 
 static void
-gst_ossmixer_track_init (GstOssMixerTrack *track)
+gst_ossmixer_device_init (GstOssMixerDevice *device)
 {
-  track->lvol = track->rvol = 0;
-  track->track_num = 0;
+  device->lvol = device->rvol = 0;
+  device->device_num = 0;
 }
 
-GstMixerTrack *
-gst_ossmixer_track_new (GstOssElement *oss,
-                        gint track_num,
+GstMixerDevice *
+gst_ossmixer_device_new (GstOssElement *oss,
+                        gint device_num,
                         gint max_chans,
                         gint flags)
 {
-  GstOssMixerTrack *osstrack;
-  GstMixerTrack *track;
+  GstOssMixerDevice *ossdevice;
+  GstMixerDevice *device;
   gint volume;
 
   if (!labels)
     fill_labels ();
 
-  osstrack = g_object_new (GST_TYPE_OSSMIXER_TRACK, NULL);
-  track = GST_MIXER_TRACK (osstrack);
-  track->label = g_strdup (labels[track_num]);
-  track->num_channels = max_chans;
-  track->flags = flags;
-  track->min_volume = 0;
-  track->max_volume = 100;
-  osstrack->track_num = track_num;
+  ossdevice = g_object_new (GST_TYPE_OSSMIXER_DEVICE, NULL);
+  device = GST_MIXER_DEVICE (ossdevice);
+  device->label = g_strdup (labels[device_num]);
+  device->num_channels = max_chans;
+  device->flags = flags;
+  device->min_volume = 0;
+  device->max_volume = 100;
+  ossdevice->device_num = device_num;
 
   /* volume */
-  if (ioctl(oss->mixer_fd, MIXER_READ (osstrack->track_num), &volume) < 0) {
+  if (ioctl(oss->mixer_fd, MIXER_READ (ossdevice->device_num), &volume) < 0) {
     g_warning("Error getting device (%d) volume: %s",
-	      osstrack->track_num, strerror(errno));
+	      ossdevice->device_num, strerror(errno));
     volume = 0;
   }
-  osstrack->lvol = (volume & 0xff);
-  if (track->num_channels == 2) {
-    osstrack->rvol = ((volume >> 8) & 0xff);
+  ossdevice->lvol = (volume & 0xff);
+  if (device->num_channels == 2) {
+    ossdevice->rvol = ((volume >> 8) & 0xff);
   }
 
-  return track;
+  return device;
 }
 
 void
@@ -213,7 +213,7 @@
 gst_ossmixer_interface_init (GstMixerClass *klass)
 {
   /* default virtual functions */
-  klass->list_tracks = gst_ossmixer_list_tracks;
+  klass->list_devices = gst_ossmixer_list_devices;
   klass->set_volume = gst_ossmixer_set_volume;
   klass->get_volume = gst_ossmixer_get_volume;
   klass->set_mute = gst_ossmixer_set_mute;
@@ -230,153 +230,153 @@
 }
 
 static gboolean
-gst_ossmixer_contains_track (GstOssElement    *oss,
-			     GstOssMixerTrack *osstrack)
+gst_ossmixer_contains_device (GstOssElement    *oss,
+			     GstOssMixerDevice *ossdevice)
 {
   const GList *item;
 
-  for (item = oss->tracklist; item != NULL; item = item->next)
-    if (item->data == osstrack)
+  for (item = oss->devicelist; item != NULL; item = item->next)
+    if (item->data == ossdevice)
       return TRUE;
 
   return FALSE;
 }
 
 static const GList *
-gst_ossmixer_list_tracks (GstMixer *mixer)
+gst_ossmixer_list_devices (GstMixer *mixer)
 {
-  return (const GList *) GST_OSSELEMENT (mixer)->tracklist;
+  return (const GList *) GST_OSSELEMENT (mixer)->devicelist;
 }
 
 static void
 gst_ossmixer_get_volume (GstMixer      *mixer,
-			 GstMixerTrack *track,
+			 GstMixerDevice *device,
 			 gint          *volumes)
 {
   gint volume;
   GstOssElement *oss = GST_OSSELEMENT (mixer);
-  GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
+  GstOssMixerDevice *ossdevice = GST_OSSMIXER_DEVICE (device);
 
   /* assert that we're opened and that we're using a known item */
   g_return_if_fail (oss->mixer_fd != -1);
-  g_return_if_fail (gst_ossmixer_contains_track (oss, osstrack));
+  g_return_if_fail (gst_ossmixer_contains_device (oss, ossdevice));
 
-  if (track->flags & GST_MIXER_TRACK_MUTE) {
-    volumes[0] = osstrack->lvol;
-    if (track->num_channels == 2) {
-      volumes[1] = osstrack->rvol;
+  if (device->flags & GST_MIXER_DEVICE_MUTE) {
+    volumes[0] = ossdevice->lvol;
+    if (device->num_channels == 2) {
+      volumes[1] = ossdevice->rvol;
     }
   } else {
     /* get */
-    if (ioctl(oss->mixer_fd, MIXER_READ (osstrack->track_num), &volume) < 0) {
+    if (ioctl(oss->mixer_fd, MIXER_READ (ossdevice->device_num), &volume) < 0) {
       g_warning("Error getting recording device (%d) volume: %s",
-	        osstrack->track_num, strerror(errno));
+	        ossdevice->device_num, strerror(errno));
       volume = 0;
     }
 
-    osstrack->lvol = volumes[0] = (volume & 0xff);
-    if (track->num_channels == 2) {
-      osstrack->rvol = volumes[1] = ((volume >> 8) & 0xff);
+    ossdevice->lvol = volumes[0] = (volume & 0xff);
+    if (device->num_channels == 2) {
+      ossdevice->rvol = volumes[1] = ((volume >> 8) & 0xff);
     }
   }
 }
 
 static void
 gst_ossmixer_set_volume (GstMixer      *mixer,
-			 GstMixerTrack *track,
+			 GstMixerDevice *device,
 			 gint          *volumes)
 {
   gint volume;
   GstOssElement *oss = GST_OSSELEMENT (mixer);
-  GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
+  GstOssMixerDevice *ossdevice = GST_OSSMIXER_DEVICE (device);
 
   /* assert that we're opened and that we're using a known item */
   g_return_if_fail (oss->mixer_fd != -1);
-  g_return_if_fail (gst_ossmixer_contains_track (oss, osstrack));
+  g_return_if_fail (gst_ossmixer_contains_device (oss, ossdevice));
 
   /* prepare the value for ioctl() */
-  if (!(track->flags & GST_MIXER_TRACK_MUTE)) {
+  if (!(device->flags & GST_MIXER_DEVICE_MUTE)) {
     volume = (volumes[0] & 0xff);
-    if (track->num_channels == 2) {
+    if (device->num_channels == 2) {
       volume |= ((volumes[1] & 0xff) << 8);
     }
 
     /* set */
-    if (ioctl(oss->mixer_fd, MIXER_WRITE (osstrack->track_num), &volume) < 0) {
+    if (ioctl(oss->mixer_fd, MIXER_WRITE (ossdevice->device_num), &volume) < 0) {
       g_warning("Error setting recording device (%d) volume (0x%x): %s",
-	        osstrack->track_num, volume, strerror(errno));
+	        ossdevice->device_num, volume, strerror(errno));
       return;
     }
   }
 
-  osstrack->lvol = volumes[0];
-  if (track->num_channels == 2) {
-    osstrack->rvol = volumes[1];
+  ossdevice->lvol = volumes[0];
+  if (device->num_channels == 2) {
+    ossdevice->rvol = volumes[1];
   }
 }
 
 static void
 gst_ossmixer_set_mute (GstMixer      *mixer,
-		       GstMixerTrack *track,
+		       GstMixerDevice *device,
 		       gboolean       mute)
 {
   int volume;
   GstOssElement *oss = GST_OSSELEMENT (mixer);
-  GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
+  GstOssMixerDevice *ossdevice = GST_OSSMIXER_DEVICE (device);
 
   /* assert that we're opened and that we're using a known item */
   g_return_if_fail (oss->mixer_fd != -1);
-  g_return_if_fail (gst_ossmixer_contains_track (oss, osstrack));
+  g_return_if_fail (gst_ossmixer_contains_device (oss, ossdevice));
 
   if (mute) {
     volume = 0;
   } else {
-    volume = (osstrack->lvol & 0xff);
-    if (MASK_BIT_IS_SET (oss->stereomask, osstrack->track_num)) {
-      volume |= ((osstrack->rvol & 0xff) << 8);
+    volume = (ossdevice->lvol & 0xff);
+    if (MASK_BIT_IS_SET (oss->stereomask, ossdevice->device_num)) {
+      volume |= ((ossdevice->rvol & 0xff) << 8);
     }
   }
 
-  if (ioctl(oss->mixer_fd, MIXER_WRITE(osstrack->track_num), &volume) < 0) {
+  if (ioctl(oss->mixer_fd, MIXER_WRITE(ossdevice->device_num), &volume) < 0) {
     g_warning("Error setting mixer recording device volume (0x%x): %s",
 	      volume, strerror(errno));
     return;
   }
 
   if (mute) {
-    track->flags |= GST_MIXER_TRACK_MUTE;
+    device->flags |= GST_MIXER_DEVICE_MUTE;
   } else {
-    track->flags &= ~GST_MIXER_TRACK_MUTE;
+    device->flags &= ~GST_MIXER_DEVICE_MUTE;
   }
 }
 
 static void
 gst_ossmixer_set_record (GstMixer      *mixer,
-			 GstMixerTrack *track,
+			 GstMixerDevice *device,
 			 gboolean       record)
 {
   GstOssElement *oss = GST_OSSELEMENT (mixer);
-  GstOssMixerTrack *osstrack = GST_OSSMIXER_TRACK (track);
+  GstOssMixerDevice *ossdevice = GST_OSSMIXER_DEVICE (device);
 
   /* assert that we're opened and that we're using a known item */
   g_return_if_fail (oss->mixer_fd != -1);
-  g_return_if_fail (gst_ossmixer_contains_track (oss, osstrack));
+  g_return_if_fail (gst_ossmixer_contains_device (oss, ossdevice));
 
   /* if we're exclusive, then we need to unset the current one(s) */
   if (oss->mixcaps & SOUND_CAP_EXCL_INPUT) {
-    GList *track;
-    for (track = oss->tracklist; track != NULL; track = track->next) {
-      GstMixerTrack *turn = (GstMixerTrack *) track->data;
-      turn->flags &= ~GST_MIXER_TRACK_RECORD;
+    GList *device;
+    for (device = oss->devicelist; device != NULL; device = device->next) {
+      GstMixerDevice *turn = (GstMixerDevice *) device->data;
+      turn->flags &= ~GST_MIXER_DEVICE_RECORD;
     }
     oss->recdevs = 0;
   }
 
   /* set new record bit, if needed */
   if (record) {
-    oss->recdevs |= (1 << osstrack->track_num);
+    oss->recdevs |= (1 << ossdevice->device_num);
   } else {
-    oss->recdevs &= ~(1 << osstrack->track_num);
+    oss->recdevs &= ~(1 << ossdevice->device_num);
   }
 
   /* set it to the device */
@@ -387,9 +387,9 @@
   }
 
   if (record) {
-    track->flags |= GST_MIXER_TRACK_RECORD;
+    device->flags |= GST_MIXER_DEVICE_RECORD;
   } else {
-    track->flags &= ~GST_MIXER_TRACK_RECORD;
+    device->flags &= ~GST_MIXER_DEVICE_RECORD;
   }
 }
 
@@ -432,13 +432,13 @@
     oss->device_name = g_strdup (minfo.name);
   }
 
-  /* build track list */
+  /* build device list */
   for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
     if (devmask & (1 << i)) {
-      GstMixerTrack *track;
+      GstMixerDevice *device;
       gboolean input = FALSE, stereo = FALSE, record = FALSE;
 
-      /* track exists, make up capabilities */
+      /* device exists, make up capabilities */
       if (MASK_BIT_IS_SET (oss->stereomask, i))
         stereo = TRUE;
       if (MASK_BIT_IS_SET (oss->recmask, i))
@@ -451,12 +451,12 @@
           (dir == GST_PAD_SINK && i == SOUND_MIXER_PCM))
         continue;
 
-      /* add track to list */
-      track = gst_ossmixer_track_new (oss, i, stereo ? 2 : 1,
-					  (record ? GST_MIXER_TRACK_RECORD : 0) |
-					  (input ? GST_MIXER_TRACK_INPUT :
-						   GST_MIXER_TRACK_OUTPUT));
-      oss->tracklist = g_list_append (oss->tracklist, track);
+      /* add device to list */
+      device = gst_ossmixer_device_new (oss, i, stereo ? 2 : 1,
+					  (record ? GST_MIXER_DEVICE_RECORD : 0) |
+					  (input ? GST_MIXER_DEVICE_INPUT :
+						   GST_MIXER_DEVICE_OUTPUT));
+      oss->devicelist = g_list_append (oss->devicelist, device);
     }
   }
 }
@@ -467,9 +467,9 @@
   if (oss->mixer_fd == -1)
     return;
 
-  g_list_foreach (oss->tracklist, (GFunc) g_object_unref, NULL);
-  g_list_free (oss->tracklist);
-  oss->tracklist = NULL;
+  g_list_foreach (oss->devicelist, (GFunc) g_object_unref, NULL);
+  g_list_free (oss->devicelist);
+  oss->devicelist = NULL;
 
   if (oss->device_name) {
     g_free (oss->device_name);
Index: sys/oss/gstossmixer.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/sys/oss/gstossmixer.h,v
retrieving revision 1.4
diff -u -r1.4 gstossmixer.h
--- sys/oss/gstossmixer.h	10 Oct 2003 12:24:20 -0000	1.4
+++ sys/oss/gstossmixer.h	3 Nov 2003 21:46:06 -0000
@@ -28,31 +28,31 @@
 
 G_BEGIN_DECLS
 
-#define GST_TYPE_OSSMIXER_TRACK \
-  (gst_ossmixer_track_get_type ())
-#define GST_OSSMIXER_TRACK(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_OSSMIXER_TRACK, \
-			       GstOssMixerTrack))
-#define GST_OSSMIXER_TRACK_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_OSSMIXER_TRACK, \
-			    GstOssMixerTrackClass))
-#define GST_IS_OSSMIXER_TRACK(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_OSSMIXER_TRACK))
-#define GST_IS_OSSMIXER_TRACK_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_OSSMIXER_TRACK))
+#define GST_TYPE_OSSMIXER_DEVICE \
+  (gst_ossmixer_device_get_type ())
+#define GST_OSSMIXER_DEVICE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_OSSMIXER_DEVICE, \
+			       GstOssMixerDevice))
+#define GST_OSSMIXER_DEVICE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_OSSMIXER_DEVICE, \
+			    GstOssMixerDeviceClass))
+#define GST_IS_OSSMIXER_DEVICE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_OSSMIXER_DEVICE))
+#define GST_IS_OSSMIXER_DEVICE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_OSSMIXER_DEVICE))
 
-typedef struct _GstOssMixerTrack {
-  GstMixerTrack parent;
+typedef struct _GstOssMixerDevice {
+  GstMixerDevice parent;
 
   gint          lvol, rvol;
-  gint          track_num;
-} GstOssMixerTrack;
+  gint          device_num;
+} GstOssMixerDevice;
 
-typedef struct _GstOssMixerTrackClass {
-  GstMixerTrackClass parent;
-} GstOssMixerTrackClass;
+typedef struct _GstOssMixerDeviceClass {
+  GstMixerDeviceClass parent;
+} GstOssMixerDeviceClass;
 
-GType	gst_ossmixer_track_get_type	(void);
+GType	gst_ossmixer_device_get_type	(void);
 
 void	gst_ossmixer_interface_init	(GstMixerClass *klass);
 void	gst_oss_interface_init		(GstInterfaceClass *klass);
Index: gst-libs/gst/mixer/Makefile.am
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst-libs/gst/mixer/Makefile.am,v
retrieving revision 1.3
diff -u -r1.3 Makefile.am
--- gst-libs/gst/mixer/Makefile.am	30 Oct 2003 02:36:41 -0000	1.3
+++ gst-libs/gst/mixer/Makefile.am	3 Nov 2003 21:46:06 -0000
@@ -3,11 +3,11 @@
 
 libgstinterfacesinclude_HEADERS = \
 	mixer.h \
-	mixertrack.h
+	mixerdevice.h
 
 noinst_LTLIBRARIES = libgstmixer.la
 
 libgstmixer_la_SOURCES = \
 	mixer.c \
-	mixertrack.c
+	mixerdevice.c
 libgstmixer_la_CFLAGS = $(GST_CFLAGS)
Index: gst-libs/gst/mixer/mixer.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst-libs/gst/mixer/mixer.c,v
retrieving revision 1.4
diff -u -r1.4 mixer.c
--- gst-libs/gst/mixer/mixer.c	10 Oct 2003 12:24:20 -0000	1.4
+++ gst-libs/gst/mixer/mixer.c	3 Nov 2003 21:46:06 -0000
@@ -59,7 +59,7 @@
 gst_mixer_class_init (GstMixerClass *klass)
 {
   /* default virtual functions */
-  klass->list_tracks = NULL;
+  klass->list_devices = NULL;
   klass->set_volume = NULL;
   klass->get_volume = NULL;
   klass->set_mute = NULL;
@@ -67,12 +67,12 @@
 }
 
 const GList *
-gst_mixer_list_tracks (GstMixer *mixer)
+gst_mixer_list_devices (GstMixer *mixer)
 {
   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 
-  if (klass->list_tracks) {
-    return klass->list_tracks (mixer);
+  if (klass->list_devices) {
+    return klass->list_devices (mixer);
   }
 
   return NULL;
@@ -80,29 +80,29 @@
 
 void
 gst_mixer_set_volume (GstMixer      *mixer,
-		      GstMixerTrack *track,
+		      GstMixerDevice *device,
 		      gint          *volumes)
 {
   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 
   if (klass->set_volume) {
-    klass->set_volume (mixer, track, volumes);
+    klass->set_volume (mixer, device, volumes);
   }
 }
 
 void
 gst_mixer_get_volume (GstMixer      *mixer,
-		      GstMixerTrack *track,
+		      GstMixerDevice *device,
 		      gint          *volumes)
 {
   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 
   if (klass->get_volume) {
-    klass->get_volume (mixer, track, volumes);
+    klass->get_volume (mixer, device, volumes);
   } else {
     gint i;
 
-    for (i = 0; i < track->num_channels; i++) {
+    for (i = 0; i < device->num_channels; i++) {
       volumes[i] = 0;
     }
   }
@@ -110,24 +110,24 @@
 
 void
 gst_mixer_set_mute (GstMixer      *mixer,
-		    GstMixerTrack *track,
+		    GstMixerDevice *device,
 		    gboolean       mute)
 {
   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 
   if (klass->set_mute) {
-    klass->set_mute (mixer, track, mute);
+    klass->set_mute (mixer, device, mute);
   }
 }
 
 void
 gst_mixer_set_record (GstMixer      *mixer,
-		      GstMixerTrack *track,
+		      GstMixerDevice *device,
 		      gboolean       record)
 {
   GstMixerClass *klass = GST_MIXER_GET_CLASS (mixer);
 
   if (klass->set_record) {
-    klass->set_record (mixer, track, record);
+    klass->set_record (mixer, device, record);
   }
 }
Index: gst-libs/gst/mixer/mixer.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst-libs/gst/mixer/mixer.h,v
retrieving revision 1.5
diff -u -r1.5 mixer.h
--- gst-libs/gst/mixer/mixer.h	10 Oct 2003 12:24:20 -0000	1.5
+++ gst-libs/gst/mixer/mixer.h	3 Nov 2003 21:46:06 -0000
@@ -23,7 +23,7 @@
 #define __GST_MIXER_H__
 
 #include <gst/gst.h>
-#include <gst/mixer/mixertrack.h>
+#include <gst/mixer/mixerdevice.h>
 
 G_BEGIN_DECLS
 
@@ -46,20 +46,20 @@
   GTypeInterface klass;
 
   /* virtual functions */
-  const GList *  (* list_tracks)   (GstMixer      *mixer);
+  const GList *  (* list_devices)   (GstMixer      *mixer);
 
   void           (* set_volume)    (GstMixer      *mixer,
-				    GstMixerTrack *track,
+				    GstMixerDevice *device,
 				    gint          *volumes);
   void           (* get_volume)    (GstMixer      *mixer,
-				    GstMixerTrack *track,
+				    GstMixerDevice *device,
 				    gint          *volumes);
 
   void           (* set_mute)      (GstMixer      *mixer,
-				    GstMixerTrack *track,
+				    GstMixerDevice *device,
 				    gboolean       mute);
   void           (* set_record)    (GstMixer      *mixer,
-				    GstMixerTrack *track,
+				    GstMixerDevice *device,
 				    gboolean       record);
 
   GST_CLASS_PADDING
@@ -68,18 +68,18 @@
 GType		gst_mixer_get_type	(void);
 
 /* virtual class function wrappers */
-const GList *	gst_mixer_list_tracks	(GstMixer      *mixer);
+const GList *	gst_mixer_list_devices	(GstMixer      *mixer);
 void		gst_mixer_set_volume	(GstMixer      *mixer,
-					 GstMixerTrack *track,
+					 GstMixerDevice *device,
 					 gint          *volumes);
 void		gst_mixer_get_volume	(GstMixer      *mixer,
-					 GstMixerTrack *track,
+					 GstMixerDevice *device,
 					 gint          *volumes);
 void		gst_mixer_set_mute	(GstMixer      *mixer,
-					 GstMixerTrack *track,
+					 GstMixerDevice *device,
 					 gboolean       mute);
 void		gst_mixer_set_record	(GstMixer      *mixer,
-					 GstMixerTrack *track,
+					 GstMixerDevice *device,
 					 gboolean       record);
 
 G_END_DECLS
Index: gst-libs/gst/mixer/mixertrack.c
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst-libs/gst/mixer/mixertrack.c,v
retrieving revision 1.1
diff -u -r1.1 mixertrack.c
--- gst-libs/gst/mixer/mixertrack.c	10 Oct 2003 12:24:20 -0000	1.1
+++ gst-libs/gst/mixer/mixertrack.c	3 Nov 2003 21:46:06 -0000
@@ -1,7 +1,7 @@
 /* GStreamer Mixer
  * Copyright (C) 2003 Ronald Bultje <rbultje at ronald.bitfreak.net>
  *
- * mixertrack.c: mixer track object design
+ * mixerdevice.c: mixer device object design
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -23,7 +23,7 @@
 #include "config.h"
 #endif
 
-#include "mixertrack.h"
+#include "mixerdevice.h"
 
 enum {
   /* FILL ME */
@@ -33,43 +33,43 @@
   LAST_SIGNAL
 };
 
-static void gst_mixer_track_class_init (GstMixerTrackClass *klass);
-static void gst_mixer_track_init       (GstMixerTrack      *mixer);
-static void gst_mixer_track_dispose    (GObject            *object);
+static void gst_mixer_device_class_init (GstMixerDeviceClass *klass);
+static void gst_mixer_device_init       (GstMixerDevice      *mixer);
+static void gst_mixer_device_dispose    (GObject            *object);
 
 static GObjectClass *parent_class = NULL;
 static guint signals[LAST_SIGNAL] = { 0 };
 
 GType
-gst_mixer_track_get_type (void)
+gst_mixer_device_get_type (void)
 {
-  static GType gst_mixer_track_type = 0;
+  static GType gst_mixer_device_type = 0;
 
-  if (!gst_mixer_track_type) {
-    static const GTypeInfo mixer_track_info = {
-      sizeof (GstMixerTrackClass),
+  if (!gst_mixer_device_type) {
+    static const GTypeInfo mixer_device_info = {
+      sizeof (GstMixerDeviceClass),
       NULL,
       NULL,
-      (GClassInitFunc) gst_mixer_track_class_init,
+      (GClassInitFunc) gst_mixer_device_class_init,
       NULL,
       NULL,
-      sizeof (GstMixerTrack),
+      sizeof (GstMixerDevice),
       0,
-      (GInstanceInitFunc) gst_mixer_track_init,
+      (GInstanceInitFunc) gst_mixer_device_init,
       NULL
     };
 
-    gst_mixer_track_type =
+    gst_mixer_device_type =
 	g_type_register_static (G_TYPE_OBJECT,
-				"GstMixerTrack",
-				&mixer_track_info, 0);
+				"GstMixerDevice",
+				&mixer_device_info, 0);
   }
 
-  return gst_mixer_track_type;
+  return gst_mixer_device_type;
 }
 
 static void
-gst_mixer_track_class_init (GstMixerTrackClass *klass)
+gst_mixer_device_class_init (GstMixerDeviceClass *klass)
 {
   GObjectClass *object_klass = (GObjectClass *) klass;
 
@@ -78,30 +78,30 @@
   signals[SIGNAL_RECORD_TOGGLED] =
     g_signal_new ("record_toggled", G_TYPE_FROM_CLASS (klass),
 		  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GstMixerTrackClass,
+                  G_STRUCT_OFFSET (GstMixerDeviceClass,
 				   record_toggled),
                   NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN,
                   G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
   signals[SIGNAL_MUTE_TOGGLED] =
     g_signal_new ("mute_toggled", G_TYPE_FROM_CLASS (klass),
 		  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GstMixerTrackClass,
+                  G_STRUCT_OFFSET (GstMixerDeviceClass,
 				   mute_toggled),
                   NULL, NULL, g_cclosure_marshal_VOID__BOOLEAN,
                   G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
   signals[SIGNAL_VOLUME_CHANGED] =
     g_signal_new ("volume_changed", G_TYPE_FROM_CLASS (klass),
 		  G_SIGNAL_RUN_LAST,
-                  G_STRUCT_OFFSET (GstMixerTrackClass,
+                  G_STRUCT_OFFSET (GstMixerDeviceClass,
 				   volume_changed),
                   NULL, NULL, g_cclosure_marshal_VOID__POINTER,
                   G_TYPE_NONE, 1, G_TYPE_POINTER);
 
-  object_klass->dispose = gst_mixer_track_dispose;
+  object_klass->dispose = gst_mixer_device_dispose;
 }
 
 static void
-gst_mixer_track_init (GstMixerTrack *channel)
+gst_mixer_device_init (GstMixerDevice *channel)
 {
   channel->label = NULL;
   channel->min_volume = channel->max_volume = 0;
@@ -110,9 +110,9 @@
 }
 
 static void
-gst_mixer_track_dispose (GObject *object)
+gst_mixer_device_dispose (GObject *object)
 {
-  GstMixerTrack *channel = GST_MIXER_TRACK (object);
+  GstMixerDevice *channel = GST_MIXER_DEVICE (object);
 
   if (channel->label)
     g_free (channel->label);
Index: gst-libs/gst/mixer/mixertrack.h
===================================================================
RCS file: /cvsroot/gstreamer/gst-plugins/gst-libs/gst/mixer/mixertrack.h,v
retrieving revision 1.1
diff -u -r1.1 mixertrack.h
--- gst-libs/gst/mixer/mixertrack.h	10 Oct 2003 12:24:20 -0000	1.1
+++ gst-libs/gst/mixer/mixertrack.h	3 Nov 2003 21:46:06 -0000
@@ -1,7 +1,7 @@
 /* GStreamer Mixer
  * Copyright (C) 2003 Ronald Bultje <rbultje at ronald.bitfreak.net>
  *
- * mixertrack.h: mixer track object
+ * mixerdevice.h: mixer device object
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ -19,68 +19,68 @@
  * Boston, MA 02111-1307, USA.
  */
 
-#ifndef __GST_MIXER_TRACK_H__
-#define __GST_MIXER_TRACK_H__
+#ifndef __GST_MIXER_DEVICE_H__
+#define __GST_MIXER_DEVICE_H__
 
 #include <gst/gst.h>
 
 G_BEGIN_DECLS
 
-#define GST_TYPE_MIXER_TRACK \
-  (gst_mixer_track_get_type ())
-#define GST_MIXER_TRACK(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_MIXER_TRACK, \
-			       GstMixerTrack))
-#define GST_MIXER_TRACK_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_MIXER_TRACK, \
-			    GstMixerTrackClass))
-#define GST_IS_MIXER_TRACK(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MIXER_TRACK))
-#define GST_IS_MIXER_TRACK_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_MIXER_TRACK))
+#define GST_TYPE_MIXER_DEVICE \
+  (gst_mixer_device_get_type ())
+#define GST_MIXER_DEVICE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_MIXER_DEVICE, \
+			       GstMixerDevice))
+#define GST_MIXER_DEVICE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_MIXER_DEVICE, \
+			    GstMixerDeviceClass))
+#define GST_IS_MIXER_DEVICE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_MIXER_DEVICE))
+#define GST_IS_MIXER_DEVICE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_MIXER_DEVICE))
 
 /*
  * Naming:
  *
- * A track is a single input/output stream (e.g. line-in,
+ * A device is a single input/output stream (e.g. line-in,
  * microphone, etc.). Channels are then single streams
- * within a track. A mono stream has one channel, a stereo
+ * within a device. A mono stream has one channel, a stereo
  * stream has two, etc.
  */
 
 typedef enum {
-  GST_MIXER_TRACK_INPUT  = (1<<0),
-  GST_MIXER_TRACK_OUTPUT = (1<<1),
-  GST_MIXER_TRACK_MUTE   = (1<<2),
-  GST_MIXER_TRACK_RECORD = (1<<3),
-} GstMixerTrackFlags;
+  GST_MIXER_DEVICE_INPUT  = (1<<0),
+  GST_MIXER_DEVICE_OUTPUT = (1<<1),
+  GST_MIXER_DEVICE_MUTE   = (1<<2),
+  GST_MIXER_DEVICE_RECORD = (1<<3),
+} GstMixerDeviceFlags;
 
-#define GST_MIXER_TRACK_HAS_FLAG(channel, flag) \
+#define GST_MIXER_DEVICE_HAS_FLAG(channel, flag) \
   ((channel)->flags & flag)
 
-typedef struct _GstMixerTrack {
+typedef struct _GstMixerDevice {
   GObject            parent;
 
   gchar             *label;
-  GstMixerTrackFlags flags;
+  GstMixerDeviceFlags flags;
   gint               num_channels,
 	             min_volume,
 	             max_volume;
-} GstMixerTrack;
+} GstMixerDevice;
 
-typedef struct _GstMixerTrackClass {
+typedef struct _GstMixerDeviceClass {
   GObjectClass parent;
 
-  void (* mute_toggled)   (GstMixerTrack *channel,
+  void (* mute_toggled)   (GstMixerDevice *channel,
 			   gboolean       on);
-  void (* record_toggled) (GstMixerTrack *channel,
+  void (* record_toggled) (GstMixerDevice *channel,
 			   gboolean       on);
-  void (* volume_changed) (GstMixerTrack *channel,
+  void (* volume_changed) (GstMixerDevice *channel,
 			   gint          *volumes);
-} GstMixerTrackClass;
+} GstMixerDeviceClass;
 
-GType		gst_mixer_track_get_type	(void);
+GType		gst_mixer_device_get_type	(void);
 
 G_END_DECLS
 
-#endif /* __GST_MIXER_TRACK_H__ */
+#endif /* __GST_MIXER_DEVICE_H__ */


More information about the gstreamer-devel mailing list