cdparanoia added

Original commit message from CVS:
cdparanoia added

configure.ac

@@ -435,6 +435,7 @@ dnl *** CDParanoia ***
 translit(dnm, m, l) AM_CONDITIONAL(USE_CDPARANOIA, true)
 GST_CHECK_FEATURE(CDPARANOIA, [CDParanoia], cdparanoia, [
   GST_CHECK_LIBHEADER(CDPARANOIA, cdda_interface, cdda_open, , cdda_interface.h, CDPARANOIA_LIBS="-lcdda_interface -lcdda_paranoia")
+  AC_SUBST(CDPARANOIA_LIBS)
 ])
 dnl FIXME : add second check somehow if that is necessary
 dnl AC_CHECK_LIB(cdda_paranoia, paranoia_init, : , HAVE_CDPARANOIA=no, -lcdda_interface )
@@ -914,7 +915,6 @@ AM_CONDITIONAL(HAVE_PDFTOPS,        $HAVE_PDFTOPS)
 AM_CONDITIONAL(HAVE_XSLTPROC,       $HAVE_XSLTPROC)
 AM_CONDITIONAL(HAVE_FIG2DEV_PNG,    $HAVE_FIG2DEV_PNG)
 AM_CONDITIONAL(HAVE_FIG2DEV_PDF,    $HAVE_FIG2DEV_PDF)
-AM_CONDITIONAL(HAVE_CDPARANOIA,     test "x$HAVE_CDPARANOIA" = "xyes")
 AM_CONDITIONAL(HAVE_LIBSHOUT,       test "x$HAVE_LIBSHOUT" = "xyes")
 AM_CONDITIONAL(HAVE_A52DEC,         test "x$HAVE_A52DEC" = "xyes")
 AM_CONDITIONAL(HAVE_AVIFILE,        test "x$HAVE_AVIFILE" = "xyes")
@@ -1083,6 +1083,7 @@ ext/aalib/Makefile
 ext/alsa/Makefile
 ext/audiofile/Makefile
 ext/avifile/Makefile
+ext/cdparanoia/Makefile
 ext/dvdread/Makefile
 ext/esd/Makefile
 ext/lame/Makefile

ext/Makefile.am

@@ -28,6 +28,11 @@ else
 AVIFILE_DIR=
 endif
 
+if USE_CDPARANOIA
+CDPARANOIA_DIR=cdparanoia
+else
+CDPARANOIA_DIR=
+endif
 
 if USE_DVDREAD
 DVDREAD_DIR=dvdread
@@ -72,9 +77,9 @@ VORBIS_DIR=
 endif
 
 SUBDIRS=$(A52_DIR) $(AALIB_DIR) $(ALSA_DIR) $(AUDIOFILE_DIR) \
-	$(AVIFILE_DIR) $(DVDREAD_DIR) $(ESD_DIR) \
+	$(AVIFILE_DIR) $(CDPARANOIA_DIR) $(DVDREAD_DIR) $(ESD_DIR) \
         $(LAME_DIR) $(MAD_DIR) $(MPEG2DEC_DIR) \
 	$(SDL_DIR) $(VORBIS_DIR)
 
-DIST_SUBDIRS=a52 aalib alsa avifile audiofile dvdread esd \
+DIST_SUBDIRS=a52 aalib alsa avifile audiofile cdparanoia dvdread esd \
 	     lame mad mpeg2dec sdl vorbis

ext/cdparanoia/Makefile.am

@@ -0,0 +1,9 @@
+plugindir = $(libdir)/gst
+
+plugin_LTLIBRARIES = libgstcdparanoia.la
+
+libgstcdparanoia_la_SOURCES = gstcdparanoia.c
+libgstcdparanoia_la_LIBADD = $(CDPARANOIA_LIBS)
+libgstcdparanoia_la_CFLAGS = $(GST_CFLAGS)
+
+noinst_HEADERS = gstcdparanoia.h

ext/cdparanoia/gstcdparanoia.c

@@ -0,0 +1,656 @@
+/* Gnome-Streamer
+ * 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.
+ */
+
+//#define GST_DEBUG_ENABLED
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+
+#include "gstcdparanoia.h"
+
+
+static GstElementDetails cdparanoia_details = {
+  "CD Audio (cdda) Source, Paranoia IV",
+  "Source/File/CDDA",
+  "Read audio from CD in paranoid mode",
+  VERSION,
+  "Erik Walthinsen <omega@cse.ogi.edu>",
+  "(C) 2000",
+};
+
+GST_PADTEMPLATE_FACTORY (cdparanoia_src_factory,
+  "src",
+  GST_PAD_SRC,
+  GST_PAD_ALWAYS,
+  GST_CAPS_NEW (
+    "cdparanoia_src",
+    "audio/raw",
+      "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 (44100),
+        "channels",   GST_PROPS_INT (2),
+        "chunksize",  GST_PROPS_INT (CD_FRAMESIZE_RAW)
+  )
+);
+
+
+/********** Define useful types for non-programmatic interfaces **********/
+#define GST_TYPE_PARANOIA_MODE (gst_lame_paranoia_get_type())
+static GType
+gst_lame_paranoia_get_type (void)
+{
+  static GType paranoia_mode_type = 0;
+  static GEnumValue paranoia_modes[] = {
+    { 0, "0", "Disable paranoid checking" },
+    { 1, "1", "cdda2wav-style overlap checking" },
+    { 2, "2", "Full paranoia" },
+    { 0, NULL, NULL },
+  };
+  if (!paranoia_mode_type) {
+    paranoia_mode_type = g_enum_register_static ("GstParanoiaMode", paranoia_modes);
+  }
+  return paranoia_mode_type;
+}
+
+
+/********** Standard stuff for signals and arguments **********/
+/* CDParanoia signals and args */
+enum {
+  SMILIE_CHANGE,
+  TRANSPORT_ERROR,
+  UNCORRECTED_ERROR,
+  LAST_SIGNAL
+};
+
+enum {
+  ARG_0,
+  ARG_LOCATION,
+  ARG_GENERIC_DEVICE,
+  ARG_START_TRACK,
+  ARG_END_TRACK,
+  ARG_LAST_TRACK,
+  ARG_CUR_TRACK,
+  ARG_START_SECTOR,
+  ARG_END_SECTOR,
+  ARG_CUR_SECTOR,
+  ARG_DEFAULT_SECTORS,
+  ARG_SEARCH_OVERLAP,
+  ARG_ENDIAN,
+  ARG_READ_SPEED,
+  ARG_TOC_OFFSET,
+  ARG_TOC_BIAS,
+  ARG_NEVER_SKIP,
+  ARG_ABORT_ON_SKIP,
+  ARG_PARANOIA_MODE,
+  ARG_SMILIE,
+};
+
+
+static void			cdparanoia_class_init		(CDParanoiaClass *klass);
+static void			cdparanoia_init			(CDParanoia *cdparanoia);
+
+static void			cdparanoia_set_property		(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void			cdparanoia_get_property		(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
+
+static GstBuffer*		cdparanoia_get			(GstPad *pad);
+
+static GstElementStateReturn	cdparanoia_change_state		(GstElement *element);
+
+
+static GstElementClass *parent_class = NULL;
+static guint cdparanoia_signals[LAST_SIGNAL] = { 0 };
+
+GType
+cdparanoia_get_type (void)
+{
+  static GType cdparanoia_type = 0;
+
+  if (!cdparanoia_type) {
+    static const GTypeInfo cdparanoia_info = {
+      sizeof(CDParanoiaClass),      NULL,
+      NULL,
+      (GClassInitFunc)cdparanoia_class_init,
+      NULL,
+      NULL,
+      sizeof(CDParanoia),
+      0,
+      (GInstanceInitFunc)cdparanoia_init,
+    };
+    cdparanoia_type = g_type_register_static (GST_TYPE_ELEMENT, "CDParanoia", &cdparanoia_info, 0);
+  }
+  return cdparanoia_type;
+}
+
+static void
+cdparanoia_class_init (CDParanoiaClass *klass)
+{
+  GObjectClass *gobject_class;
+  GstElementClass *gstelement_class;
+
+  gobject_class = (GObjectClass*)klass;
+  gstelement_class = (GstElementClass*)klass;
+
+  parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
+
+  cdparanoia_signals[SMILIE_CHANGE] =
+    g_signal_new ("smilie_change", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
+                   G_STRUCT_OFFSET (CDParanoiaClass, smilie_change), NULL, NULL,
+                   g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
+  cdparanoia_signals[TRANSPORT_ERROR] =
+    g_signal_new ("transport_error", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
+                   G_STRUCT_OFFSET (CDParanoiaClass, transport_error), NULL, NULL,
+                   g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
+  cdparanoia_signals[UNCORRECTED_ERROR] =
+    g_signal_new ("uncorrected_error", G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_LAST,
+                   G_STRUCT_OFFSET (CDParanoiaClass, uncorrected_error), NULL, NULL,
+                   g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
+
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_LOCATION,
+    g_param_spec_string("location","location","location",
+                        NULL, G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_GENERIC_DEVICE,
+    g_param_spec_string("generic_device","generic_device","generic_device",
+                        NULL, G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_START_TRACK,
+    g_param_spec_int("start_track","start_track","start_track",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_END_TRACK,
+    g_param_spec_int("end_track","end_track","end_track",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_LAST_TRACK,
+    g_param_spec_int("last_track","last_track","last_track",
+                     G_MININT,G_MAXINT,0,G_PARAM_READABLE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CUR_TRACK,
+    g_param_spec_int("cur_track","cur_track","cur_track",
+                     G_MININT,G_MAXINT,0,G_PARAM_READABLE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_START_SECTOR,
+    g_param_spec_int("start_sector","start_sector","start_sector",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_END_SECTOR,
+    g_param_spec_int("end_sector","end_sector","end_sector",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_CUR_SECTOR,
+    g_param_spec_int("cur_sector","cur_sector","cur_sector",
+                     G_MININT,G_MAXINT,0,G_PARAM_READABLE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_DEFAULT_SECTORS,
+    g_param_spec_int("default_sectors","default_sectors","default_sectors",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SEARCH_OVERLAP,
+    g_param_spec_int("search_overlap","search_overlap","search_overlap",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_ENDIAN,
+    g_param_spec_int("endian","endian","endian",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_READ_SPEED,
+    g_param_spec_int("read_speed","read_speed","read_speed",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_TOC_OFFSET,
+    g_param_spec_int("toc_offset","toc_offset","toc_offset",
+                     G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_TOC_BIAS,
+    g_param_spec_boolean("toc_bias","toc_bias","toc_bias",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_NEVER_SKIP,
+    g_param_spec_boolean("never_skip","never_skip","never_skip",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_ABORT_ON_SKIP,
+    g_param_spec_boolean("abort_on_skip","abort_on_skip","abort_on_skip",
+                         TRUE,G_PARAM_READWRITE)); // CHECKME
+  g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_PARANOIA_MODE,
+    g_param_spec_enum("paranoia_mode","paranoia_mode","paranoia_mode",
+                      GST_TYPE_PARANOIA_MODE,0,G_PARAM_READWRITE)); // CHECKME!
+
+  gobject_class->set_property = cdparanoia_set_property;
+  gobject_class->get_property = cdparanoia_get_property;
+
+  gstelement_class->change_state = cdparanoia_change_state;
+}
+
+static void
+cdparanoia_init (CDParanoia *cdparanoia)
+{
+  cdparanoia->srcpad = gst_pad_new_from_template (
+		  GST_PADTEMPLATE_GET (cdparanoia_src_factory), "src");
+  gst_pad_set_get_function (cdparanoia->srcpad, cdparanoia_get);
+  gst_pad_set_caps (cdparanoia->srcpad, gst_pad_get_padtemplate_caps (cdparanoia->srcpad));
+  gst_element_add_pad (GST_ELEMENT (cdparanoia), cdparanoia->srcpad);
+
+  cdparanoia->device = "/dev/cdrom";
+  cdparanoia->generic_device = NULL;
+  cdparanoia->start_sector = -1;
+  cdparanoia->end_sector = -1;
+  cdparanoia->cur_sector = -1;
+  cdparanoia->start_track = -1;
+  cdparanoia->cur_track = -1;
+  cdparanoia->end_track = -1;
+  cdparanoia->last_track = -1;
+  cdparanoia->default_sectors = -1;
+  cdparanoia->search_overlap = -1;
+  cdparanoia->endian = -1;
+  cdparanoia->read_speed = -1;
+  cdparanoia->toc_offset = 0;
+  cdparanoia->toc_bias = FALSE;
+  cdparanoia->never_skip = FALSE;
+  cdparanoia->paranoia_mode = 2;
+  cdparanoia->abort_on_skip = FALSE;
+
+  cdparanoia->cur_sector = 0;
+  cdparanoia->seq = 0;
+}
+
+
+static void
+cdparanoia_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  CDParanoia *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail (GST_IS_CDPARANOIA (object));
+
+  src = CDPARANOIA (object);
+
+  switch (prop_id) {
+    case ARG_LOCATION:
+      /* the element must be stopped in order to do this */
+//      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      if (src->device) g_free (src->device);
+      /* clear the filename if we get a NULL (is that possible?) */
+      if (g_value_get_string (value) == NULL)
+        src->device = NULL;
+      /* otherwise set the new filename */
+      else
+        src->device = g_strdup (g_value_get_string (value));
+      break;
+    case ARG_GENERIC_DEVICE:
+      /* the element must be stopped in order to do this */
+//      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING));
+
+      if (src->generic_device) g_free (src->generic_device);
+      /* reset the device if we get a NULL (is that possible?) */
+      if (g_value_get_string (value) == NULL)
+        src->generic_device = NULL;
+      /* otherwise set the new filename */
+      else
+        src->generic_device = g_strdup (g_value_get_string (value));
+      break;
+    case ARG_START_SECTOR:
+      src->start_sector = g_value_get_int (value);
+      break;
+    case ARG_END_SECTOR:
+      src->end_sector = g_value_get_int (value);
+      break;
+    case ARG_START_TRACK:
+      src->start_track = g_value_get_int (value);
+      break;
+    case ARG_END_TRACK:
+      src->end_track = g_value_get_int (value);
+      break;  
+    case ARG_DEFAULT_SECTORS:
+      src->default_sectors = g_value_get_int (value);
+      break;
+    case ARG_SEARCH_OVERLAP:
+      src->search_overlap = g_value_get_int (value);
+      break;
+    case ARG_ENDIAN:
+      src->endian = g_value_get_int (value);
+      break;
+    case ARG_READ_SPEED:
+      src->read_speed = g_value_get_int (value);
+      break;
+    case ARG_TOC_OFFSET:
+      src->toc_offset = g_value_get_int (value);
+      break;
+    case ARG_TOC_BIAS:
+      src->toc_bias = g_value_get_boolean (value);
+      break;
+    case ARG_NEVER_SKIP:
+      src->never_skip = g_value_get_boolean (value);
+      break;
+    case ARG_ABORT_ON_SKIP:
+      src->abort_on_skip = g_value_get_boolean (value);
+      break;
+    case ARG_PARANOIA_MODE:
+      src->paranoia_mode = g_value_get_int (value);
+      break;
+    default:
+      break;
+  }
+
+}
+
+static void
+cdparanoia_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  CDParanoia *src;
+
+  /* it's not null if we got it, but it might not be ours */
+  g_return_if_fail (GST_IS_CDPARANOIA (object));
+
+  src = CDPARANOIA (object);
+
+  switch (prop_id) {
+    case ARG_LOCATION:
+      g_value_set_string (value, src->device);
+      break;
+    case ARG_GENERIC_DEVICE:
+      g_value_set_string (value, src->generic_device);
+      break;
+    case ARG_START_SECTOR:
+      g_value_set_int (value, src->start_sector);
+      break;
+    case ARG_END_SECTOR:
+      g_value_set_int (value, src->end_sector);
+      break;
+    case ARG_CUR_SECTOR:
+      g_value_set_int (value, src->cur_sector);
+      break;
+    case ARG_START_TRACK:
+      g_value_set_int (value, src->start_track);
+      break;
+    case ARG_END_TRACK:
+      g_value_set_int (value, src->end_track);
+      break;
+    case ARG_CUR_TRACK:
+      g_value_set_int (value, src->cur_track);
+      break;
+    case ARG_LAST_TRACK:
+      g_value_set_int (value, src->last_track);
+      break;
+    case ARG_DEFAULT_SECTORS:
+      g_value_set_int (value, src->default_sectors);
+      break;
+    case ARG_SEARCH_OVERLAP:
+      g_value_set_int (value, src->search_overlap);
+      break;
+    case ARG_ENDIAN:
+      g_value_set_int (value, src->endian);
+      break;
+    case ARG_READ_SPEED:
+      g_value_set_int (value, src->read_speed);
+      break;
+    case ARG_TOC_OFFSET:
+      g_value_set_int (value, src->toc_offset);
+      break;
+    case ARG_TOC_BIAS:
+      g_value_set_boolean (value, src->toc_bias);
+      break;
+    case ARG_NEVER_SKIP:
+      g_value_set_boolean (value, src->never_skip);
+      break;
+    case ARG_ABORT_ON_SKIP:
+      g_value_set_boolean (value, src->abort_on_skip);
+      break;
+    case ARG_PARANOIA_MODE:
+      g_value_set_int (value, src->paranoia_mode);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+  }
+}
+
+static void cdparanoia_callback(long inpos, int function) {
+}
+
+static GstBuffer*
+cdparanoia_get (GstPad *pad)
+{
+  CDParanoia *src;
+  GstBuffer *buf;
+  static gint16 *cdda_buf;
+
+  g_return_val_if_fail (pad != NULL, NULL);
+  src = CDPARANOIA (gst_pad_get_parent (pad));
+  g_return_val_if_fail (GST_FLAG_IS_SET (src, CDPARANOIA_OPEN), NULL);
+
+  // create a new buffer
+  buf = gst_buffer_new ();
+  g_return_val_if_fail (buf, NULL);
+
+  // read a sector
+// NOTE: if you have a patched cdparanoia, set this to 1 to save cycles
+#if 0
+  cdda_buf = paranoia_read (src->p, NULL);
+#else
+  cdda_buf = paranoia_read (src->p, cdparanoia_callback);
+#endif
+
+  // update current sector and stop things if appropriate
+  src->cur_sector++;
+
+  src->cur_track = cdda_sector_gettrack( src->d, src->cur_sector );
+
+  if (src->cur_sector == src->end_sector) {
+    GST_DEBUG (0,"setting EOS flag on outgoing buffer\n");
+    GST_BUFFER_FLAG_SET (buf,GST_BUFFER_EOS);
+    gst_element_signal_eos(GST_ELEMENT(src));
+  }
+
+  // have to copy the buffer for now since we don't own it...
+  // FIXME must ask monty about allowing ownership transfer
+  GST_BUFFER_DATA (buf) = g_malloc(CD_FRAMESIZE_RAW);
+  memcpy (GST_BUFFER_DATA (buf), cdda_buf, CD_FRAMESIZE_RAW);
+  GST_BUFFER_SIZE (buf) = CD_FRAMESIZE_RAW;
+
+
+  /* we're done, push the buffer off now */
+  return buf;
+}
+
+/* open the file, necessary to go to RUNNING state */
+static gboolean
+cdparanoia_open (CDParanoia *src)
+{
+  gint i;
+  gint paranoia_mode;
+
+  g_return_val_if_fail (!GST_FLAG_IS_SET (src, CDPARANOIA_OPEN), FALSE);
+
+  GST_DEBUG_ENTER("(\"%s\",...)", gst_element_get_name (GST_ELEMENT (src)));
+
+  // find the device
+  if (src->generic_device != NULL) {
+    src->d = cdda_identify_scsi (src->generic_device, src->device, FALSE, NULL);
+  } else {
+    if (src->device != NULL) {
+      src->d = cdda_identify (src->device, FALSE, NULL);
+    } else {
+      src->d = cdda_identify ("/dev/cdrom", FALSE, NULL);
+    }
+  }
+
+  // fail if the device couldn't be found
+  if (src->d == NULL) {
+    GST_DEBUG (0,"couldn't open device\n");
+    return FALSE;
+  }
+
+  // set verbosity mode
+  cdda_verbose_set (src->d, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
+
+  // set various other parameters
+  if (src->default_sectors != -1) {
+    if ((src->default_sectors < 0) || (src->default_sectors > 100)) {
+      GST_DEBUG (0,"default sector read size must be 1 <= n <= 100\n");
+      cdda_close (src->d);
+      src->d = NULL;
+      return FALSE;
+    } else {
+      src->d->nsectors = src->default_sectors;
+      src->d->bigbuff = src->default_sectors * CD_FRAMESIZE_RAW;
+    }
+  }
+  if (src->search_overlap != -1) {
+    if ((src->search_overlap < 0) || (src->search_overlap > 75)) {
+      GST_DEBUG (0,"search overlap must be 0 <= n <= 75\n");
+      cdda_close (src->d);
+      src->d = NULL;
+      return FALSE;
+    }
+  }
+
+  // open the disc
+  if (cdda_open (src->d)) {
+    GST_DEBUG (0,"couldn't open disc\n");
+    cdda_close (src->d);
+    src->d = NULL;
+    return FALSE;
+  }
+
+  // set up some more stuff
+  if (src->toc_bias) {
+    src->toc_offset -= cdda_track_firstsector (src->d, 1);
+  }
+  for (i=0;i<src->d->tracks + 1;i++) {
+    src->d->disc_toc[i].dwStartSector += src->toc_offset;
+  }
+
+  if (src->read_speed != -1) {
+    cdda_speed_set (src->d, src->read_speed);
+  }
+
+  // if the start_track is set, override the start_sector
+  if (src->start_track != -1) {
+    src->start_sector = cdda_track_firstsector (src->d, src->start_track);
+  // if neither start_track nor start_sector is set,
+  } else if (src->start_sector == -1) {
+    src->start_sector = cdda_disc_firstsector (src->d);
+  }
+  // if the end_track is set, override the end_sector
+  if (src->end_track != -1) {
+    src->end_sector = cdda_track_lastsector (src->d, src->end_track);
+  // if neither end_track nor end_sector is set,
+  } else if (src->end_sector == -1) {
+    src->end_sector = cdda_disc_lastsector (src->d);
+  }
+
+  // set last_track
+  src->last_track = cdda_tracks (src->d);
+
+  // create the paranoia struct and set it up
+  src->p = paranoia_init (src->d);
+  if (src->p == NULL) {
+    GST_DEBUG (0,"couldn't create paranoia struct\n");
+    return FALSE;
+  }
+
+  if (src->paranoia_mode == 0) paranoia_mode = PARANOIA_MODE_DISABLE;
+  else if (src->paranoia_mode == 1) paranoia_mode = PARANOIA_MODE_OVERLAP;
+  else paranoia_mode = PARANOIA_MODE_FULL;
+  if (src->never_skip) paranoia_mode |= PARANOIA_MODE_NEVERSKIP;
+  paranoia_modeset (src->p, paranoia_mode);
+
+  if (src->search_overlap != -1) {
+    paranoia_overlapset (src->p, src->search_overlap);
+  }
+
+  src->cur_sector = src->start_sector;
+  paranoia_seek (src->p, src->cur_sector, SEEK_SET);
+  GST_DEBUG (0,"successfully seek'd to beginning of disk\n");
+
+  GST_FLAG_SET (src, CDPARANOIA_OPEN);
+
+  GST_DEBUG_LEAVE("");
+
+  return TRUE;
+}
+
+/* close the file */
+static void
+cdparanoia_close (CDParanoia *src)
+{
+  g_return_if_fail (GST_FLAG_IS_SET (src, CDPARANOIA_OPEN));
+
+  // kill the paranoia state
+  paranoia_free (src->p);
+  src->p = NULL;
+
+  // close the disc
+  cdda_close (src->d);
+  src->d = NULL;
+
+  GST_FLAG_UNSET (src, CDPARANOIA_OPEN);
+}
+
+static GstElementStateReturn
+cdparanoia_change_state (GstElement *element)
+{
+  g_return_val_if_fail (GST_IS_CDPARANOIA (element), GST_STATE_FAILURE);
+
+  /* if going down into NULL state, close the file if it's open */
+  if (GST_STATE_PENDING (element) == GST_STATE_NULL) {
+    if (GST_FLAG_IS_SET (element, CDPARANOIA_OPEN))
+      cdparanoia_close (CDPARANOIA (element));
+  /* otherwise (READY or higher) we need to open the file */
+  } else {
+    if (!GST_FLAG_IS_SET (element, CDPARANOIA_OPEN)) {
+      if (!cdparanoia_open (CDPARANOIA (element))) {
+        g_print("failed opening cd\n");
+        return GST_STATE_FAILURE;
+      }
+    }
+  }
+
+  /* if we haven't failed already, give the parent class a chance too ;-) */
+  if (GST_ELEMENT_CLASS (parent_class)->change_state)
+    return GST_ELEMENT_CLASS (parent_class)->change_state (element);
+
+  return GST_STATE_SUCCESS;
+}
+
+static gboolean
+plugin_init (GModule *module, GstPlugin *plugin)
+{
+  GstElementFactory *factory;
+
+  /* create an elementfactory for the cdparanoia element */
+  factory = gst_elementfactory_new ("cdparanoia", GST_TYPE_CDPARANOIA,
+                                    &cdparanoia_details);
+  g_return_val_if_fail (factory != NULL, FALSE);
+
+  /* register the source's caps */
+  gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (cdparanoia_src_factory));
+
+  /* and add the cdparanoia element factory to the plugin */
+  gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
+
+  return TRUE;
+}
+
+GstPluginDesc plugin_desc = {
+  GST_VERSION_MAJOR,
+  GST_VERSION_MINOR,
+  "cdparanoia",
+  plugin_init
+};

ext/cdparanoia/gstcdparanoia.h

@@ -0,0 +1,106 @@
+/* Gnome-Streamer
+ * 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 __CDPARANOIA_H__
+#define __CDPARANOIA_H__
+
+
+#include <config.h>
+#include <glib.h>
+#include <gst/gst.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define size16 gint16
+#define size32 gint32
+#include <cdda_interface.h>
+#include <cdda_paranoia.h>
+
+
+//#define CDPARANOIA_BASEOFFSET 0xf1d2
+#define CDPARANOIA_BASEOFFSET 0x0
+
+#define GST_TYPE_CDPARANOIA \
+  (cdparanoia_get_type())
+#define CDPARANOIA(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CDPARANOIA,CDParanoia))
+#define CDPARANOIA_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CDPARANOIA,CDParanoiaClass))
+#define GST_IS_CDPARANOIA(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CDPARANOIA))
+#define GST_IS_CDPARANOIA_CLASS(obj) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CDPARANOIA))
+
+// NOTE: per-element flags start with 16 for now
+typedef enum {
+  CDPARANOIA_OPEN		= GST_ELEMENT_FLAG_LAST,
+
+  CDPARANOIA_FLAG_LAST		= GST_ELEMENT_FLAG_LAST+2,
+} CDParanoiaFlags;
+
+typedef struct _CDParanoia CDParanoia;
+typedef struct _CDParanoiaClass CDParanoiaClass;
+
+struct _CDParanoia {
+  GstElement element;
+  /* pads */
+  GstPad *srcpad;
+
+  gchar *device;
+  gchar *generic_device;
+  gint start_track, end_track, cur_track;
+  gint start_sector, end_sector;
+  gint last_track;
+  gint default_sectors;
+  gint search_overlap;
+  gint endian;
+  gint read_speed;
+  gint toc_offset;
+  gboolean toc_bias;
+  gboolean never_skip;
+  gboolean abort_on_skip;
+  gint paranoia_mode;
+
+  cdrom_drive *d;
+  cdrom_paranoia *p;
+
+  gulong cur_sector;			/* current offset in file */
+  gulong seq;				/* buffer sequence number */
+};
+
+struct _CDParanoiaClass {
+  GstElementClass parent_class;
+
+  /* signal callbacks */
+  void (*smilie_change)		(CDParanoia *cdparanoia, gchar *smilie);
+  void (*transport_error)	(CDParanoia *cdparanoia, gint offset);
+  void (*uncorrected_error)	(CDParanoia *cdparanoia, gint offset);
+};
+
+GType cdparanoia_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __CDPARANOIA_H__ */