gstreamer/gst/real/gstrealaudiodec.c

/* RealAudio wrapper plugin
 *
 * Copyright (C) 2006 Lutz Mueller <lutz@topfrose.de>
 * Copyright (C) 2006 Edward Hervey <bilboed@bilboed.com>
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "gstreal.h"
#include "gstrealaudiodec.h"

#include <string.h>

GST_DEBUG_CATEGORY_STATIC (real_audio_dec_debug);
#define GST_CAT_DEFAULT real_audio_dec_debug

static GstStaticPadTemplate snk_t =
    GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("audio/x-pn-realaudio, "
        "raversion = { 3, 4, 5, 6, 8 }; " "audio/x-sipro "));

static GstStaticPadTemplate src_t =
GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
    GST_STATIC_CAPS ("audio/x-raw-int, "
        "width = (int) [ 1, MAX ], "
        "depth = (int) [ 1, MAX ], "
        "rate = (int) [ 1, MAX ], " "channels = (int) [ 1, MAX ]"));

#define DEFAULT_RACOOK_NAMES "cook.so:cook.so.6.0"
#define DEFAULT_RAATRK_NAMES "atrc.so:atrc.so.6.0"
#define DEFAULT_RA14_4_NAMES "14_4.so.6.0"
#define DEFAULT_RA28_8_NAMES "28_8.so.6.0"
#define DEFAULT_RASIPR_NAMES "sipr.so:sipr.so.6.0"
#define DEFAULT_PWD "Ardubancel Quazanga"

enum
{
  PROP_0,
  PROP_REAL_CODECS_PATH,
  PROP_RACOOK_NAMES,
  PROP_RAATRK_NAMES,
  PROP_RA14_4_NAMES,
  PROP_RA28_8_NAMES,
  PROP_RASIPR_NAMES,
  PROP_PASSWORD
};

typedef enum
{
  GST_REAL_AUDIO_DEC_VERSION_ATRK = 3,
  GST_REAL_AUDIO_DEC_VERSION_14_4 = 4,
  GST_REAL_AUDIO_DEC_VERSION_28_8 = 5,
  GST_REAL_AUDIO_DEC_VERSION_SIPR = 6,
  GST_REAL_AUDIO_DEC_VERSION_COOK = 8
} GstRealAudioDecVersion;

typedef struct
{
  /* Hooks */
  GModule *module;

  /* Used by the REAL library. */
  gpointer context;

    guint16 (*RADecode) (gpointer, guint8 *, guint32, guint8 *, guint32 *,
      guint32);
    guint16 (*RACloseCodec) (gpointer);
    guint16 (*RAFreeDecoder) (gpointer);
    guint16 (*RAInitDecoder) (gpointer, gpointer);
    guint16 (*RAOpenCodec2) (gpointer, const gchar *);
    guint16 (*RASetFlavor) (gpointer, guint16);
  void (*SetDLLAccessPath) (gchar *);
  void (*RASetPwd) (gpointer, const gchar *);
} GstRADecLibrary;

typedef struct
{
  guint32 samplerate;
  guint16 width;
  guint16 channels;
  guint16 quality;
  guint32 leaf_size;
  guint32 packet_size;
  guint32 datalen;
  gpointer data;
} RAInit;

struct _GstRealAudioDec
{
  GstElement parent;

  GstPad *src, *snk;

  /* Caps */
  guint width, height, leaf_size;

  GstRADecLibrary lib;

  /* Properties */
  gboolean checked_modules;
  gchar *real_codecs_path;
  gchar *raatrk_names;
  gboolean valid_atrk;
  gchar *ra14_4_names;
  gboolean valid_ra14_4;
  gchar *ra28_8_names;
  gboolean valid_ra28_8;
  gchar *rasipr_names;
  gboolean valid_sipr;
  gchar *racook_names;
  gboolean valid_cook;
  gchar *pwd;
};

struct _GstRealAudioDecClass
{
  GstElementClass parent_class;
};

GST_BOILERPLATE (GstRealAudioDec, gst_real_audio_dec, GstElement,
    GST_TYPE_ELEMENT);

static GstFlowReturn
gst_real_audio_dec_chain (GstPad * pad, GstBuffer * in)
{
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (GST_PAD_PARENT (pad));
  GstFlowReturn flow;
  GstClockTime timestamp;
  GstBuffer *out = NULL;
  guint16 res = 0;
  guint len;

  if (G_UNLIKELY (dec->lib.RADecode == NULL || dec->lib.module == NULL))
    goto not_negotiated;

  timestamp = GST_BUFFER_TIMESTAMP (in);

  flow = gst_pad_alloc_buffer (dec->src, GST_BUFFER_OFFSET_NONE,
      dec->width * dec->leaf_size * dec->height * 16,
      GST_PAD_CAPS (dec->src), &out);

  if (flow != GST_FLOW_OK)
    goto done;

  res = dec->lib.RADecode (dec->lib.context, GST_BUFFER_DATA (in),
      GST_BUFFER_SIZE (in), GST_BUFFER_DATA (out), &len, -1);

  if (res != 0)
    goto could_not_decode;

  GST_BUFFER_SIZE (out) = len;
  GST_BUFFER_TIMESTAMP (out) = timestamp;

  flow = gst_pad_push (dec->src, out);

done:
  gst_buffer_unref (in);
  return flow;

  /* Errors */
could_not_decode:
  {
    gst_buffer_unref (out);
    GST_ELEMENT_ERROR (dec, STREAM, DECODE, (NULL),
        ("Could not decode buffer (%i).", res));
    flow = GST_FLOW_ERROR;
    goto done;
  }
not_negotiated:
  {
    GST_WARNING_OBJECT (dec, "decoder not open, probably no input caps set "
        "yet, caps on input buffer: %" GST_PTR_FORMAT, GST_BUFFER_CAPS (in));
    flow = GST_FLOW_NOT_NEGOTIATED;
    goto done;
  }
}

static void
close_library (GstRealAudioDec * dec, GstRADecLibrary * lib)
{
  if (lib->context) {
    GST_LOG_OBJECT (dec, "closing library");
    if (lib->RACloseCodec)
      lib->RACloseCodec (lib->context);
    /* lib->RAFreeDecoder (lib->context); */
  }
  if (lib->module) {
    GST_LOG_OBJECT (dec, "closing library module");
    g_module_close (lib->module);
  }
  memset (lib, 0, sizeof (GstRADecLibrary));
}

static gboolean
open_library (GstRealAudioDec * dec, gint version, GstRADecLibrary * lib)
{
  const gchar *path, *names;
  gchar **split_names, **split_path;
  gint i, j;
  gpointer ra_close_codec, ra_decode, ra_free_decoder;
  gpointer ra_open_codec2, ra_init_decoder, ra_set_flavor;
  gpointer set_dll_access_path = NULL, ra_set_pwd = NULL;
  gchar *tmppath = NULL;
  guint16 res = 0;

  path = dec->real_codecs_path ? dec->real_codecs_path :
      DEFAULT_REAL_CODECS_PATH;

  switch (version) {
    case GST_REAL_AUDIO_DEC_VERSION_COOK:
      names = dec->racook_names ? dec->racook_names : DEFAULT_RACOOK_NAMES;
      break;
    case GST_REAL_AUDIO_DEC_VERSION_ATRK:
      names = dec->raatrk_names ? dec->raatrk_names : DEFAULT_RAATRK_NAMES;
      break;
    case GST_REAL_AUDIO_DEC_VERSION_14_4:
      names = dec->ra14_4_names ? dec->ra14_4_names : DEFAULT_RA14_4_NAMES;
      break;
    case GST_REAL_AUDIO_DEC_VERSION_28_8:
      names = dec->ra28_8_names ? dec->ra28_8_names : DEFAULT_RA28_8_NAMES;
      break;
    case GST_REAL_AUDIO_DEC_VERSION_SIPR:
      names = dec->rasipr_names ? dec->rasipr_names : DEFAULT_RASIPR_NAMES;
      break;
    default:
      goto unknown_version;
  }

  GST_LOG_OBJECT (dec, "splitting paths %s, names %s", path, names);

  split_path = g_strsplit (path, ":", 0);
  split_names = g_strsplit (names, ":", 0);

  for (i = 0; split_path[i]; i++) {
    for (j = 0; split_names[j]; j++) {
      gchar *codec = g_strconcat (split_path[i], "/", split_names[j], NULL);

      GST_LOG_OBJECT (dec, "opening module %s", codec);

      /* This is racy, but it doesn't matter here; would be nice if GModule
       * gave us a GError instead of an error string, but it doesn't, so.. */
      if (g_file_test (codec, G_FILE_TEST_EXISTS)) {
        lib->module = g_module_open (codec, G_MODULE_BIND_LAZY);
        if (lib->module == NULL) {
          GST_ERROR_OBJECT (dec, "Could not open codec library '%s': %s",
              codec, g_module_error ());
        }
      } else {
        GST_DEBUG_OBJECT (dec, "%s does not exist", codec);
      }
      g_free (codec);
      if (lib->module)
        goto codec_search_done;
    }
  }

codec_search_done:
  /* we keep the path for a while to set the dll access path */
  g_strfreev (split_names);

  if (lib->module == NULL)
    goto could_not_open;

  GST_LOG_OBJECT (dec, "finding symbols");

  if (!g_module_symbol (lib->module, "RACloseCodec", &ra_close_codec) ||
      !g_module_symbol (lib->module, "RADecode", &ra_decode) ||
      !g_module_symbol (lib->module, "RAFreeDecoder", &ra_free_decoder) ||
      !g_module_symbol (lib->module, "RAOpenCodec2", &ra_open_codec2) ||
      !g_module_symbol (lib->module, "RAInitDecoder", &ra_init_decoder) ||
      !g_module_symbol (lib->module, "RASetFlavor", &ra_set_flavor)) {
    goto could_not_load;
  }

  g_module_symbol (lib->module, "RASetPwd", &ra_set_pwd);
  g_module_symbol (lib->module, "SetDLLAccessPath", &set_dll_access_path);

  lib->RACloseCodec = (guint16 (*)(gpointer)) ra_close_codec;
  lib->RADecode =
      (guint16 (*)(gpointer, guint8 *, guint32, guint8 *, guint32 *, guint32))
      ra_decode;
  lib->RAFreeDecoder = (guint16 (*)(gpointer)) ra_free_decoder;
  lib->RAOpenCodec2 = (guint16 (*)(gpointer, const gchar *)) ra_open_codec2;
  lib->RAInitDecoder = (guint16 (*)(gpointer, gpointer)) ra_init_decoder;
  lib->RASetFlavor = (guint16 (*)(gpointer, guint16)) ra_set_flavor;
  lib->RASetPwd = (void (*)(gpointer, const gchar *)) ra_set_pwd;
  lib->SetDLLAccessPath = (void (*)(gchar *)) set_dll_access_path;

  if (lib->SetDLLAccessPath)
    lib->SetDLLAccessPath (split_path[i]);

  tmppath = g_strdup_printf ("%s/", split_path[i]);
  if ((res = lib->RAOpenCodec2 (&lib->context, tmppath))) {
    g_free (tmppath);
    goto could_not_initialize;
  }
  g_free (tmppath);

  /* now we are done with the split paths, so free them */
  g_strfreev (split_path);

  return TRUE;

  /* ERRORS */
unknown_version:
  {
    GST_DEBUG_OBJECT (dec, "Cannot handle version %i.", version);
    return FALSE;
  }
could_not_open:
  {
    g_strfreev (split_path);
    GST_DEBUG_OBJECT (dec, "Could not find library '%s' in '%s'", names, path);
    return FALSE;
  }
could_not_load:
  {
    g_strfreev (split_path);
    close_library (dec, lib);
    GST_DEBUG_OBJECT (dec, "Could not load all symbols: %s", g_module_error ());
    return FALSE;
  }
could_not_initialize:
  {
    close_library (dec, lib);
    GST_WARNING_OBJECT (dec, "Initialization of REAL driver failed (%i).", res);
    return FALSE;
  }
}

static void
gst_real_audio_dec_probe_modules (GstRealAudioDec * dec)
{
  GstRADecLibrary dummy = { NULL };

  if ((dec->valid_atrk =
          open_library (dec, GST_REAL_AUDIO_DEC_VERSION_ATRK, &dummy)))
    close_library (dec, &dummy);
  if ((dec->valid_ra14_4 =
          open_library (dec, GST_REAL_AUDIO_DEC_VERSION_14_4, &dummy)))
    close_library (dec, &dummy);
  if ((dec->valid_ra28_8 =
          open_library (dec, GST_REAL_AUDIO_DEC_VERSION_28_8, &dummy)))
    close_library (dec, &dummy);
#ifdef HAVE_CPU_X86_64
  /* disabled because it does not seem to work on 64 bits */
  dec->valid_sipr = FALSE;
#else
  if ((dec->valid_sipr =
          open_library (dec, GST_REAL_AUDIO_DEC_VERSION_SIPR, &dummy)))
    close_library (dec, &dummy);
#endif
  if ((dec->valid_cook =
          open_library (dec, GST_REAL_AUDIO_DEC_VERSION_COOK, &dummy)))
    close_library (dec, &dummy);
}

static GstCaps *
gst_real_audio_dec_getcaps (GstPad * pad)
{
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (GST_PAD_PARENT (pad));
  GstCaps *res;

  if (dec->checked_modules) {
    GValue versions = { 0 };
    GValue version = { 0 };

    GST_LOG_OBJECT (dec, "constructing caps");

    g_value_init (&versions, GST_TYPE_LIST);
    g_value_init (&version, G_TYPE_INT);

    if (dec->valid_atrk) {
      g_value_set_int (&version, GST_REAL_AUDIO_DEC_VERSION_ATRK);
      gst_value_list_append_value (&versions, &version);
    }
    if (dec->valid_ra14_4) {
      g_value_set_int (&version, GST_REAL_AUDIO_DEC_VERSION_14_4);
      gst_value_list_append_value (&versions, &version);
    }
    if (dec->valid_ra28_8) {
      g_value_set_int (&version, GST_REAL_AUDIO_DEC_VERSION_28_8);
      gst_value_list_append_value (&versions, &version);
    }
    if (dec->valid_sipr) {
      g_value_set_int (&version, GST_REAL_AUDIO_DEC_VERSION_SIPR);
      gst_value_list_append_value (&versions, &version);
    }
    if (dec->valid_cook) {
      g_value_set_int (&version, GST_REAL_AUDIO_DEC_VERSION_COOK);
      gst_value_list_append_value (&versions, &version);
    }

    if (gst_value_list_get_size (&versions) > 0) {
      res = gst_caps_new_simple ("audio/x-pn-realaudio", NULL);
      gst_structure_set_value (gst_caps_get_structure (res, 0),
          "raversion", &versions);
    } else {
      res = gst_caps_new_empty ();
    }

    if (dec->valid_sipr) {
      gst_caps_append (res, gst_caps_new_simple ("audio/x-sipro", NULL));
    }
    g_value_unset (&versions);
    g_value_unset (&version);
  } else {
    GST_LOG_OBJECT (dec, "returning padtemplate caps");
    res = gst_caps_copy (gst_pad_get_pad_template_caps (pad));
  }
  GST_LOG_OBJECT (dec, "returning caps %" GST_PTR_FORMAT, res);

  return res;
}

static gboolean
gst_real_audio_dec_setcaps (GstPad * pad, GstCaps * caps)
{
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (GST_PAD_PARENT (pad));
  GstStructure *s = gst_caps_get_structure (caps, 0);
  gint version, flavor, channels, rate, leaf_size, packet_size, width, height;
  guint16 res = 0;
  RAInit data;
  gboolean bres;
  const GValue *v;
  GstBuffer *buf = NULL;
  const gchar *name = gst_structure_get_name (s);

  if (!strcmp (name, "audio/x-sipro")) {
    version = GST_REAL_AUDIO_DEC_VERSION_SIPR;
  } else {
    if (!gst_structure_get_int (s, "raversion", &version))
      goto missing_keys;
  }

  if (!gst_structure_get_int (s, "flavor", &flavor) ||
      !gst_structure_get_int (s, "channels", &channels) ||
      !gst_structure_get_int (s, "width", &width) ||
      !gst_structure_get_int (s, "rate", &rate) ||
      !gst_structure_get_int (s, "height", &height) ||
      !gst_structure_get_int (s, "leaf_size", &leaf_size) ||
      !gst_structure_get_int (s, "packet_size", &packet_size))
    goto missing_keys;

  if ((v = gst_structure_get_value (s, "codec_data")))
    buf = g_value_peek_pointer (v);

  GST_LOG_OBJECT (dec, "opening code for version %d", version);

  /* first close existing decoder */
  close_library (dec, &dec->lib);

  if (!open_library (dec, version, &dec->lib))
    goto could_not_open;

  /* we have the module, no initialize with the caps data */
  data.samplerate = rate;
  data.width = width;
  data.channels = channels;
  data.quality = 100;
  data.leaf_size = leaf_size;
  data.packet_size = packet_size;
  data.datalen = buf ? GST_BUFFER_SIZE (buf) : 0;
  data.data = buf ? GST_BUFFER_DATA (buf) : NULL;

  if ((res = dec->lib.RAInitDecoder (dec->lib.context, &data))) {
    GST_WARNING_OBJECT (dec, "RAInitDecoder() failed");
    goto could_not_initialize;
  }

  if (dec->lib.RASetPwd) {
    dec->lib.RASetPwd (dec->lib.context, dec->pwd ? dec->pwd : DEFAULT_PWD);
  }

  if ((res = dec->lib.RASetFlavor (dec->lib.context, flavor))) {
    GST_WARNING_OBJECT (dec, "RASetFlavor(%d) failed", flavor);
    goto could_not_initialize;
  }

  caps = gst_caps_new_simple ("audio/x-raw-int",
      "endianness", G_TYPE_INT, G_BYTE_ORDER,
      "width", G_TYPE_INT, width,
      "depth", G_TYPE_INT, width,
      "rate", G_TYPE_INT, rate,
      "channels", G_TYPE_INT, channels, "signed", G_TYPE_BOOLEAN, TRUE, NULL);
  bres = gst_pad_set_caps (GST_PAD (dec->src), caps);
  gst_caps_unref (caps);
  if (!bres)
    goto could_not_set_caps;

  dec->width = width;
  dec->height = height;
  dec->leaf_size = leaf_size;

  GST_LOG_OBJECT (dec, "opened module");

  return TRUE;

missing_keys:
  {
    GST_DEBUG_OBJECT (dec, "Could not find all necessary keys in structure.");
    return FALSE;
  }
could_not_open:
  {
    GST_DEBUG_OBJECT (dec, "Could not find decoder");
    return FALSE;
  }
could_not_initialize:
  {
    close_library (dec, &dec->lib);
    GST_WARNING_OBJECT (dec, "Initialization of REAL driver failed (%i).", res);
    return FALSE;
  }
could_not_set_caps:
  {
    /* should normally not fail */
    close_library (dec, &dec->lib);
    GST_DEBUG_OBJECT (dec, "Could not convince peer to accept caps.");
    return FALSE;
  }
}

static void
gst_real_audio_dec_init (GstRealAudioDec * dec, GstRealAudioDecClass * klass)
{
  dec->snk = gst_pad_new_from_static_template (&snk_t, "sink");
  gst_pad_set_setcaps_function (dec->snk,
      GST_DEBUG_FUNCPTR (gst_real_audio_dec_setcaps));
  gst_pad_set_getcaps_function (dec->snk,
      GST_DEBUG_FUNCPTR (gst_real_audio_dec_getcaps));
  gst_pad_set_chain_function (dec->snk,
      GST_DEBUG_FUNCPTR (gst_real_audio_dec_chain));
  gst_element_add_pad (GST_ELEMENT (dec), dec->snk);

  dec->src = gst_pad_new_from_static_template (&src_t, "src");
  gst_pad_use_fixed_caps (dec->src);
  gst_element_add_pad (GST_ELEMENT (dec), dec->src);
}

static void
gst_real_audio_dec_base_init (gpointer g_class)
{
  GstElementClass *ec = GST_ELEMENT_CLASS (g_class);

  gst_element_class_add_pad_template (ec, gst_static_pad_template_get (&snk_t));
  gst_element_class_add_pad_template (ec, gst_static_pad_template_get (&src_t));
  gst_element_class_set_metadata (ec, "RealAudio decoder",
      "Codec/Decoder/Audio", "Decoder for RealAudio streams",
      "Lutz Mueller <lutz@topfrose.de>");
}

static GstStateChangeReturn
gst_real_audio_dec_change_state (GstElement * element,
    GstStateChange transition)
{
  GstStateChangeReturn ret;
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (element);

  switch (transition) {
    case GST_STATE_CHANGE_NULL_TO_READY:
      gst_real_audio_dec_probe_modules (dec);
      dec->checked_modules = TRUE;
      break;
    default:
      break;
  }

  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);

  switch (transition) {
    case GST_STATE_CHANGE_PAUSED_TO_READY:
      close_library (dec, &dec->lib);
      break;
    case GST_STATE_CHANGE_READY_TO_NULL:
      dec->checked_modules = FALSE;
      break;
    default:
      break;
  }
  return ret;
}

static void
gst_real_audio_dec_finalize (GObject * object)
{
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (object);

  close_library (dec, &dec->lib);

  if (dec->real_codecs_path) {
    g_free (dec->real_codecs_path);
    dec->real_codecs_path = NULL;
  }
  if (dec->racook_names) {
    g_free (dec->racook_names);
    dec->racook_names = NULL;
  }
  if (dec->raatrk_names) {
    g_free (dec->raatrk_names);
    dec->raatrk_names = NULL;
  }
  if (dec->ra14_4_names) {
    g_free (dec->ra14_4_names);
    dec->ra14_4_names = NULL;
  }
  if (dec->ra28_8_names) {
    g_free (dec->ra28_8_names);
    dec->ra28_8_names = NULL;
  }
  if (dec->rasipr_names) {
    g_free (dec->rasipr_names);
    dec->rasipr_names = NULL;
  }

  G_OBJECT_CLASS (parent_class)->finalize (object);
}

static void
gst_real_audio_dec_set_property (GObject * object, guint prop_id,
    const GValue * value, GParamSpec * pspec)
{
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (object);

  switch (prop_id) {
    case PROP_REAL_CODECS_PATH:
      if (dec->real_codecs_path)
        g_free (dec->real_codecs_path);
      dec->real_codecs_path = g_value_dup_string (value);
      break;
    case PROP_RACOOK_NAMES:
      if (dec->racook_names)
        g_free (dec->racook_names);
      dec->racook_names = g_value_dup_string (value);
      break;
    case PROP_RAATRK_NAMES:
      if (dec->raatrk_names)
        g_free (dec->raatrk_names);
      dec->raatrk_names = g_value_dup_string (value);
      break;
    case PROP_RA14_4_NAMES:
      if (dec->ra14_4_names)
        g_free (dec->ra14_4_names);
      dec->ra14_4_names = g_value_dup_string (value);
      break;
    case PROP_RA28_8_NAMES:
      if (dec->ra28_8_names)
        g_free (dec->ra28_8_names);
      dec->ra28_8_names = g_value_dup_string (value);
      break;
    case PROP_RASIPR_NAMES:
      if (dec->rasipr_names)
        g_free (dec->rasipr_names);
      dec->rasipr_names = g_value_dup_string (value);
      break;
    case PROP_PASSWORD:
      if (dec->pwd)
        g_free (dec->pwd);
      dec->pwd = g_value_dup_string (value);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_real_audio_dec_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstRealAudioDec *dec = GST_REAL_AUDIO_DEC (object);

  switch (prop_id) {
    case PROP_REAL_CODECS_PATH:
      g_value_set_string (value, dec->real_codecs_path ? dec->real_codecs_path
          : DEFAULT_REAL_CODECS_PATH);
      break;
    case PROP_RACOOK_NAMES:
      g_value_set_string (value, dec->racook_names ? dec->racook_names :
          DEFAULT_RACOOK_NAMES);
      break;
    case PROP_RAATRK_NAMES:
      g_value_set_string (value, dec->raatrk_names ? dec->raatrk_names :
          DEFAULT_RAATRK_NAMES);
      break;
    case PROP_RA14_4_NAMES:
      g_value_set_string (value, dec->ra14_4_names ? dec->ra14_4_names :
          DEFAULT_RA14_4_NAMES);
      break;
    case PROP_RA28_8_NAMES:
      g_value_set_string (value, dec->ra28_8_names ? dec->ra28_8_names :
          DEFAULT_RA28_8_NAMES);
      break;
    case PROP_RASIPR_NAMES:
      g_value_set_string (value, dec->rasipr_names ? dec->rasipr_names :
          DEFAULT_RASIPR_NAMES);
      break;
    case PROP_PASSWORD:
      g_value_set_string (value, dec->pwd ? dec->pwd : DEFAULT_PWD);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
gst_real_audio_dec_class_init (GstRealAudioDecClass * klass)
{
  GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->set_property = gst_real_audio_dec_set_property;
  object_class->get_property = gst_real_audio_dec_get_property;
  object_class->finalize = gst_real_audio_dec_finalize;

  element_class->change_state = gst_real_audio_dec_change_state;

  g_object_class_install_property (object_class, PROP_REAL_CODECS_PATH,
      g_param_spec_string ("real-codecs-path",
          "Path where to search for RealPlayer codecs",
          "Path where to search for RealPlayer codecs",
          DEFAULT_REAL_CODECS_PATH,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  g_object_class_install_property (object_class, PROP_RACOOK_NAMES,
      g_param_spec_string ("racook-names", "Names of cook driver",
          "Names of cook driver", DEFAULT_RACOOK_NAMES,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  g_object_class_install_property (object_class, PROP_RAATRK_NAMES,
      g_param_spec_string ("raatrk-names", "Names of atrk driver",
          "Names of atrk driver", DEFAULT_RAATRK_NAMES,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  g_object_class_install_property (object_class, PROP_RA14_4_NAMES,
      g_param_spec_string ("ra14-4-names", "Names of 14_4 driver",
          "Names of 14_4 driver", DEFAULT_RA14_4_NAMES,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  g_object_class_install_property (object_class, PROP_RA28_8_NAMES,
      g_param_spec_string ("ra28-8-names", "Names of 28_8 driver",
          "Names of 28_8 driver", DEFAULT_RA28_8_NAMES,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  g_object_class_install_property (object_class, PROP_RASIPR_NAMES,
      g_param_spec_string ("rasipr-names", "Names of sipr driver",
          "Names of sipr driver", DEFAULT_RASIPR_NAMES,
          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  g_object_class_install_property (object_class, PROP_PASSWORD,
      g_param_spec_string ("password", "Password", "Password",
          DEFAULT_PWD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  GST_DEBUG_CATEGORY_INIT (real_audio_dec_debug, "realaudiodec", 0,
      "RealAudio decoder");
}