summaryrefslogtreecommitdiffstats
path: root/gst/real/gstrealvideodec.c
diff options
context:
space:
mode:
Diffstat (limited to 'gst/real/gstrealvideodec.c')
-rw-r--r--gst/real/gstrealvideodec.c878
1 files changed, 878 insertions, 0 deletions
diff --git a/gst/real/gstrealvideodec.c b/gst/real/gstrealvideodec.c
new file mode 100644
index 00000000..3dfab829
--- /dev/null
+++ b/gst/real/gstrealvideodec.c
@@ -0,0 +1,878 @@
+/* RealVideo wrapper plugin
+ *
+ * Copyright (C) 2005 Lutz Mueller <lutz@topfrose.de>
+ * 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 "gstrealvideodec.h"
+
+#include <dlfcn.h>
+#include <string.h>
+
+GST_DEBUG_CATEGORY_STATIC (realvideode_debug);
+#define GST_CAT_DEFAULT realvideode_debug
+
+static GstElementDetails realvideode_details =
+GST_ELEMENT_DETAILS ("RealVideo decoder",
+ "Codec/Decoder", "Decoder for RealVideo streams",
+ "Lutz Mueller <lutz@topfrose.de>");
+
+static GstStaticPadTemplate snk_t =
+GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("video/x-pn-realvideo, " "rmversion = (int) [ 2, 4 ]"));
+static GstStaticPadTemplate src_t =
+GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
+ GST_STATIC_CAPS ("video/x-raw-yuv, "
+ "format = (fourcc) I420, "
+ "framerate = (fraction) [0/1, MAX], "
+ "width = (int) [ 16, 4096 ], " "height = (int) [ 16, 4096 ] "));
+
+#ifdef HAVE_CPU_I386
+#define DEFAULT_PATH_RV20 "/usr/lib/win32/drv2.so.6.0"
+#define DEFAULT_PATH_RV30 "/usr/lib/win32/drv3.so.6.0"
+#define DEFAULT_PATH_RV40 "/usr/lib/win32/drv4.so.6.0"
+#endif
+#ifdef HAVE_CPU_X86_64
+#define DEFAULT_PATH_RV20 "/usr/lib/drvc.so"
+#define DEFAULT_PATH_RV30 "/usr/lib/drvc.so"
+#define DEFAULT_PATH_RV40 "/usr/lib/drvc.so"
+#endif
+
+enum
+{
+ PROP_0,
+ PROP_PATH_RV20,
+ PROP_PATH_RV30,
+ PROP_PATH_RV40
+};
+
+
+GST_BOILERPLATE (GstRealVideoDec, gst_real_video_dec, GstElement,
+ GST_TYPE_ELEMENT);
+
+static gboolean open_library (GstRealVideoDec * dec);
+static void close_library (GstRealVideoDec * dec);
+
+typedef struct
+{
+ guint32 datalen;
+ gint32 interpolate;
+ gint32 nfragments;
+ gpointer fragments;
+ guint32 flags;
+ guint32 timestamp;
+} RVInData;
+
+typedef struct
+{
+ guint32 frames;
+ guint32 notes;
+ guint32 timestamp;
+ guint32 width;
+ guint32 height;
+} RVOutData;
+
+static GstFlowReturn
+gst_real_video_dec_alloc_buffer (GstRealVideoDec * dec, GstClockTime timestamp,
+ GstBuffer ** buf)
+{
+ GstFlowReturn ret;
+ const guint8 *b;
+ guint8 frame_type;
+ guint16 seq;
+ GstClockTime ts = timestamp;
+
+ GST_LOG_OBJECT (dec, "timestamp %" GST_TIME_FORMAT, GST_TIME_ARGS (ts));
+
+ /* Fix timestamp. */
+ b = gst_adapter_peek (dec->adapter, 4);
+ switch (dec->version) {
+ case GST_REAL_VIDEO_DEC_VERSION_2:
+ {
+
+ /*
+ * Bit 1- 2: frame type
+ * Bit 3- 9: ?
+ * Bit 10-22: sequence number
+ * Bit 23-32: ?
+ */
+ frame_type = (b[0] >> 6) & 0x03;
+ seq = ((b[1] & 0x7f) << 6) + ((b[2] & 0xfc) >> 2);
+ break;
+ }
+ case GST_REAL_VIDEO_DEC_VERSION_3:
+ {
+ /*
+ * Bit 1- 2: ?
+ * Bit 3: skip packet if 1
+ * Bit 4- 5: frame type
+ * Bit 6-12: ?
+ * Bit 13-25: sequence number
+ * Bit 26-32: ?
+ */
+ frame_type = (b[0] >> 3) & 0x03;
+ seq = ((b[1] & 0x0f) << 9) + (b[2] << 1) + ((b[3] & 0x80) >> 7);
+ break;
+ }
+ case GST_REAL_VIDEO_DEC_VERSION_4:
+ {
+ /*
+ * Bit 1: skip packet if 1
+ * Bit 2- 3: frame type
+ * Bit 4-13: ?
+ * Bit 14-26: sequence number
+ * Bit 27-32: ?
+ */
+ frame_type = (b[0] >> 5) & 0x03;
+ seq = ((b[1] & 0x07) << 10) + (b[2] << 2) + ((b[3] & 0xc0) >> 6);
+ break;
+ }
+ default:
+ goto unknown_version;
+ }
+
+ GST_LOG_OBJECT (dec, "frame_type:%d", frame_type);
+
+ switch (frame_type) {
+ case 0:
+ case 1:
+ {
+ /* I frame */
+ timestamp = dec->next_ts;
+ dec->last_ts = dec->next_ts;
+ dec->next_ts = ts;
+ dec->last_seq = dec->next_seq;
+ dec->next_seq = seq;
+
+ break;
+ }
+ case 2:
+ {
+ /* P frame */
+ timestamp = dec->last_ts = dec->next_ts;
+ if (seq < dec->next_seq)
+ dec->next_ts += (seq + 0x2000 - dec->next_seq) * GST_MSECOND;
+ else
+ dec->next_ts += (seq - dec->next_seq) * GST_MSECOND;
+ dec->last_seq = dec->next_seq;
+ dec->next_seq = seq;
+ break;
+ }
+ case 3:
+ {
+ /* B frame */
+ if (seq < dec->last_seq) {
+ timestamp = (seq + 0x2000 - dec->last_seq) * GST_MSECOND + dec->last_ts;
+ } else {
+ timestamp = (seq - dec->last_seq) * GST_MSECOND + dec->last_ts;
+ }
+
+ break;
+ }
+ default:
+ goto unknown_frame_type;
+ }
+
+ ret = gst_pad_alloc_buffer (dec->src, GST_BUFFER_OFFSET_NONE,
+ dec->width * dec->height * 3 / 2, GST_PAD_CAPS (dec->src), buf);
+
+ if (ret == GST_FLOW_OK)
+ GST_BUFFER_TIMESTAMP (*buf) = timestamp;
+
+ return ret;
+
+ /* Errors */
+unknown_version:
+ {
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE,
+ ("Unknown version: %i.", dec->version), (NULL));
+ return GST_FLOW_ERROR;
+ }
+
+unknown_frame_type:
+ {
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE, ("Unknown frame type."), (NULL));
+ return GST_FLOW_ERROR;
+ }
+}
+
+static GstFlowReturn
+gst_real_video_dec_decode (GstRealVideoDec * dec, GstBuffer * in, guint offset)
+{
+ guint32 result;
+ GstBuffer *out = NULL;
+ GstFlowReturn ret;
+ guint8 *data, hdr_subseq, hdr_seqnum;
+ guint32 hdr_offset, hdr_length;
+ guint16 n;
+ gboolean bres;
+ guint8 *buf = GST_BUFFER_DATA (in) + offset;
+ guint len = GST_BUFFER_SIZE (in) - offset;
+ GstClockTime timestamp = GST_BUFFER_TIMESTAMP (in);
+
+ GST_LOG_OBJECT (dec,
+ "Got buffer %p with timestamp %" GST_TIME_FORMAT " offset %d", in,
+ GST_TIME_ARGS (timestamp), offset);
+
+ /* Subsequence */
+ if (len < 1)
+ goto not_enough_data;
+ if (*buf != 0x40 && *buf != 0x41 && *buf != 0x42 &&
+ *buf != 0x43 && *buf != 0x44 && *buf != 0x45) {
+ hdr_subseq = *buf & 0x7f;
+ buf++;
+ len--;
+ if (hdr_subseq == 64)
+ hdr_subseq = 1;
+ } else {
+ hdr_subseq = 1;
+ }
+
+ /* Length */
+ if (len < 2)
+ goto not_enough_data;
+ hdr_length = GST_READ_UINT16_BE (buf);
+ if (!(hdr_length & 0xc000)) {
+ if (len < 4)
+ goto not_enough_data;
+ hdr_length = GST_READ_UINT32_BE (buf);
+ buf += 4;
+ len -= 4;
+ } else {
+ hdr_length &= 0x3fff;
+ buf += 2;
+ len -= 2;
+ }
+
+ /* Offset */
+ if (len < 2)
+ goto not_enough_data;
+ hdr_offset = GST_READ_UINT16_BE (buf);
+ if (!(hdr_offset & 0xc000)) {
+ if (len < 4)
+ goto not_enough_data;
+ hdr_offset = GST_READ_UINT32_BE (buf);
+ buf += 4;
+ len -= 4;
+ } else {
+ hdr_offset &= 0x3fff;
+ buf += 2;
+ len -= 2;
+ }
+
+ /* Sequence number */
+ if (len < 1)
+ goto not_enough_data;
+ hdr_seqnum = *buf;
+ buf++;
+ len--;
+ if (len < 1)
+ goto not_enough_data;
+
+ /* Verify the sequence numbers. */
+ if (hdr_subseq == 1) {
+ n = gst_adapter_available_fast (dec->adapter);
+ if (n > 0) {
+ GST_DEBUG_OBJECT (dec, "Dropping data for sequence %i "
+ "because we are already receiving data for sequence %i.",
+ dec->seqnum, hdr_seqnum);
+ gst_adapter_clear (dec->adapter);
+ }
+ dec->seqnum = hdr_seqnum;
+ dec->length = hdr_length;
+ dec->fragment_count = 1;
+ } else {
+ if (dec->seqnum != hdr_seqnum) {
+ GST_DEBUG_OBJECT (dec, "Expected sequence %i, got sequence %i "
+ "(subseq=%i). Dropping packet.", dec->seqnum, hdr_seqnum, hdr_subseq);
+ return GST_FLOW_OK;
+ } else if (dec->subseq + 1 != hdr_subseq) {
+ GST_DEBUG_OBJECT (dec, "Expected subsequence %i, got subseqence %i. "
+ "Dropping packet.", dec->subseq + 1, hdr_subseq);
+ return GST_FLOW_OK;
+ }
+ dec->fragment_count++;
+ }
+ dec->subseq = hdr_subseq;
+
+ /* Remember the offset */
+ if (sizeof (dec->fragments) < 2 * (dec->fragment_count - 1) + 1)
+ goto too_many_fragments;
+ dec->fragments[2 * (dec->fragment_count - 1)] = 1;
+ dec->fragments[2 * (dec->fragment_count - 1) + 1] =
+ gst_adapter_available (dec->adapter);
+
+ /* Some buffers need to be skipped. */
+ if (((dec->version == GST_REAL_VIDEO_DEC_VERSION_3) && (*buf & 0x20)) ||
+ ((dec->version == GST_REAL_VIDEO_DEC_VERSION_4) && (*buf & 0x80))) {
+ dec->fragment_count--;
+ dec->length -= len;
+ } else {
+ gst_adapter_push (dec->adapter,
+ gst_buffer_create_sub (in, GST_BUFFER_SIZE (in) - len, len));
+ }
+
+ /* All bytes received? */
+ n = gst_adapter_available (dec->adapter);
+ GST_LOG_OBJECT (dec, "We know have %d bytes, and we need %d", n, dec->length);
+ if (dec->length <= n) {
+ RVInData tin;
+ RVOutData tout;
+
+ if ((ret =
+ gst_real_video_dec_alloc_buffer (dec, timestamp,
+ &out)) != GST_FLOW_OK)
+ return ret;
+
+ /* Decode */
+ tin.datalen = dec->length;
+ tin.interpolate = 0;
+ tin.nfragments = dec->fragment_count - 1;
+ tin.fragments = dec->fragments;
+ tin.flags = 0;
+ tin.timestamp = GST_BUFFER_TIMESTAMP (out);
+ data = gst_adapter_take (dec->adapter, dec->length);
+
+ result = dec->transform (
+ (gchar *) data,
+ (gchar *) GST_BUFFER_DATA (out), &tin, &tout, dec->context);
+
+ g_free (data);
+ if (result)
+ goto could_not_transform;
+
+ /* Check for new dimensions */
+ if (tout.frames && ((dec->width != tout.width)
+ || (dec->height != tout.height))) {
+ GstCaps *caps = gst_caps_copy (GST_PAD_CAPS (dec->src));
+ GstStructure *s = gst_caps_get_structure (caps, 0);
+
+ GST_DEBUG_OBJECT (dec, "New dimensions: %"
+ G_GUINT32_FORMAT " x %" G_GUINT32_FORMAT, tout.width, tout.height);
+ gst_structure_set (s, "width", G_TYPE_LONG, tout.width,
+ "height", G_TYPE_LONG, tout.height, NULL);
+ bres = gst_pad_set_caps (dec->src, caps);
+ gst_caps_unref (caps);
+ if (!bres)
+ goto new_dimensions_failed;
+ dec->width = tout.width;
+ dec->height = tout.height;
+ }
+
+ GST_DEBUG_OBJECT (dec,
+ "Pushing out buffer with timestamp %" GST_TIME_FORMAT,
+ GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (out)));
+
+ if ((ret = gst_pad_push (dec->src, out)) != GST_FLOW_OK)
+ goto could_not_push;
+
+ n = gst_adapter_available (dec->adapter);
+ if (n > 0) {
+ GST_LOG_OBJECT (dec, "Data left in the adapter: %d", n);
+ in = gst_adapter_take_buffer (dec->adapter, n);
+ ret = gst_real_video_dec_decode (dec, in, 0);
+ gst_buffer_unref (in);
+ if (ret != GST_FLOW_OK)
+ return ret;
+ }
+ }
+
+ return GST_FLOW_OK;
+
+ /* Errors */
+not_enough_data:
+ {
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE, ("Not enough data."), (NULL));
+ return GST_FLOW_ERROR;
+ }
+
+too_many_fragments:
+ {
+ gst_buffer_unref (in);
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE,
+ ("Got more fragments (%i) than can be handled (%i).",
+ dec->fragment_count, sizeof (dec->fragments)), (NULL));
+ return GST_FLOW_ERROR;
+ }
+
+could_not_transform:
+ {
+ gst_buffer_unref (out);
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE,
+ ("Could not decode buffer: %" G_GUINT32_FORMAT, result), (NULL));
+ return GST_FLOW_ERROR;
+ }
+
+new_dimensions_failed:
+ {
+ gst_buffer_unref (out);
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE,
+ ("Could not set new dimensions."), (NULL));
+ return GST_FLOW_ERROR;
+ }
+
+could_not_push:
+ {
+ GST_DEBUG_OBJECT (dec, "Could not push buffer: %s",
+ gst_flow_get_name (ret));
+ return ret;
+ }
+}
+
+static GstFlowReturn
+gst_real_video_dec_chain (GstPad * pad, GstBuffer * in)
+{
+ GstRealVideoDec *dec = GST_REAL_VIDEO_DEC (GST_PAD_PARENT (pad));
+ guint8 flags, *buf = GST_BUFFER_DATA (in);
+ guint len = GST_BUFFER_SIZE (in);
+ GstFlowReturn ret;
+
+ /* Flags */
+ if (len < 1)
+ goto not_enough_data;
+ flags = *buf;
+ buf++;
+ len--;
+
+ if (flags == 0x40) {
+ GST_DEBUG_OBJECT (dec, "Don't know how to handle buffer of type 0x40 "
+ "(size=%i).", len);
+ return GST_FLOW_OK;
+ }
+
+ ret = gst_real_video_dec_decode (dec, in, 1);
+ gst_buffer_unref (in);
+ if (ret != GST_FLOW_OK)
+ return ret;
+ return GST_FLOW_OK;
+
+ /* Errors */
+not_enough_data:
+ {
+ GST_ELEMENT_ERROR (dec, STREAM, DECODE, ("Not enough data."), (NULL));
+ gst_buffer_unref (in);
+ return GST_FLOW_ERROR;
+ }
+}
+
+static gboolean
+gst_real_video_dec_activate_push (GstPad * pad, gboolean active)
+{
+ GstRealVideoDec *dec = GST_REAL_VIDEO_DEC (GST_PAD_PARENT (pad));
+
+ gst_adapter_clear (dec->adapter);
+
+ return TRUE;
+}
+
+static gboolean
+gst_real_video_dec_setcaps (GstPad * pad, GstCaps * caps)
+{
+ GstRealVideoDec *dec = GST_REAL_VIDEO_DEC (GST_PAD_PARENT (pad));
+ GstStructure *s = gst_caps_get_structure (caps, 0);
+ gint version, res;
+ gchar data[36];
+ gboolean bres;
+ const GValue *v;
+
+ if (!gst_structure_get_int (s, "rmversion", &version) ||
+ !gst_structure_get_int (s, "width", (gint *) & dec->width) ||
+ !gst_structure_get_int (s, "height", (gint *) & dec->height) ||
+ !gst_structure_get_int (s, "format", &dec->format) ||
+ !gst_structure_get_int (s, "subformat", &dec->subformat) ||
+ !gst_structure_get_fraction (s, "framerate", &dec->framerate_num,
+ &dec->framerate_denom))
+ goto missing_keys;
+ dec->version = version;
+
+ GST_LOG_OBJECT (dec, "Setting version to %d", version);
+
+ if (!open_library (dec))
+ return FALSE;
+
+ /* Initialize REAL driver. */
+ GST_WRITE_UINT16_LE (data + 0, 11);
+ GST_WRITE_UINT16_LE (data + 2, dec->width);
+ GST_WRITE_UINT16_LE (data + 4, dec->height);
+ GST_WRITE_UINT16_LE (data + 6, 0);
+ GST_WRITE_UINT32_LE (data + 8, 0);
+ GST_WRITE_UINT32_LE (data + 12, dec->subformat);
+ GST_WRITE_UINT32_LE (data + 16, 0);
+ GST_WRITE_UINT32_LE (data + 20, dec->format);
+ res = dec->init (&data, &dec->context);
+ if (res)
+ goto could_not_initialize;
+
+ if ((v = gst_structure_get_value (s, "codec_data"))) {
+ GstBuffer *buf;
+ guint32 *msgdata;
+ guint i;
+ struct
+ {
+ guint32 type;
+ guint32 msg;
+ gpointer data;
+ guint32 extra[6];
+ } msg;
+
+ buf = g_value_peek_pointer (v);
+
+ GST_LOG_OBJECT (dec, "Creating custom message of length %d",
+ GST_BUFFER_SIZE (buf));
+
+ msgdata = g_new0 (guint32, GST_BUFFER_SIZE (buf) + 2);
+ if (!msgdata)
+ goto could_not_allocate;
+
+ msg.type = 0x24;
+ msg.msg = 1 + ((dec->subformat >> 16) & 7);
+ msg.data = msgdata;
+ for (i = 0; i < 6; i++)
+ msg.extra[i] = 0;
+ msgdata[0] = dec->width;
+ msgdata[1] = dec->height;
+ for (i = 0; i < GST_BUFFER_SIZE (buf); i++)
+ msgdata[i + 2] = 4 * GST_BUFFER_DATA (buf)[i];
+
+ res = dec->custom_message (&msg, dec->context);
+
+ g_free (msgdata);
+ if (res)
+ goto could_not_send_message;
+ }
+
+ caps = gst_caps_new_simple ("video/x-raw-yuv",
+ "format", GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'),
+ "framerate", GST_TYPE_FRACTION, dec->framerate_num, dec->framerate_denom,
+ "width", G_TYPE_INT, dec->width, "height", G_TYPE_INT, dec->height, NULL);
+ bres = gst_pad_set_caps (GST_PAD (dec->src), caps);
+ gst_caps_unref (caps);
+ if (!bres)
+ goto could_not_set_caps;
+
+ return TRUE;
+
+missing_keys:
+ {
+ GST_DEBUG_OBJECT (dec, "Could not find all necessary keys in structure.");
+ return FALSE;
+ }
+
+could_not_initialize:
+ {
+ dlclose (dec->handle);
+ dec->handle = NULL;
+ GST_DEBUG_OBJECT (dec, "Initialization of REAL driver failed (%i).", res);
+ return FALSE;
+ }
+
+could_not_allocate:
+ {
+ dlclose (dec->handle);
+ dec->handle = NULL;
+ GST_DEBUG_OBJECT (dec, "Could not allocate memory.");
+ return FALSE;
+ }
+
+could_not_send_message:
+ {
+ dlclose (dec->handle);
+ dec->handle = NULL;
+ GST_DEBUG_OBJECT (dec, "Failed to send custom message needed for "
+ "initialization (%i).", res);
+ return FALSE;
+ }
+
+could_not_set_caps:
+ {
+ dlclose (dec->handle);
+ dec->handle = NULL;
+ GST_DEBUG_OBJECT (dec, "Could not convince peer to accept dimensions "
+ "%i x %i.", dec->width, dec->height);
+ return FALSE;
+ }
+}
+
+/* Attempts to open the correct library for the configured version */
+
+static gboolean
+open_library (GstRealVideoDec * dec)
+{
+ gchar *path = NULL;
+
+ GST_DEBUG_OBJECT (dec,
+ "Attempting to open shared library for real video version %d",
+ dec->version);
+
+ /* FIXME : Search for the correct library in various places if dec->path_rv20
+ * isn't set explicitely !
+ * Library names can also be different (ex : drv30.so vs drvc.so)
+ */
+
+ switch (dec->version) {
+ case GST_REAL_VIDEO_DEC_VERSION_2:
+ {
+ if (dec->path_rv20)
+ path = dec->path_rv20;
+ else if (g_file_test (DEFAULT_PATH_RV20, G_FILE_TEST_EXISTS))
+ path = DEFAULT_PATH_RV20;
+ else if (g_file_test ("/usr/lib/drv2.so.6.0", G_FILE_TEST_EXISTS))
+ path = "/usr/lib/drv2.so.6.0";
+ else
+ goto no_known_libraries;
+ break;
+ }
+ case GST_REAL_VIDEO_DEC_VERSION_3:
+ {
+ if (dec->path_rv30)
+ path = dec->path_rv30;
+ else if (g_file_test (DEFAULT_PATH_RV30, G_FILE_TEST_EXISTS))
+ path = DEFAULT_PATH_RV30;
+ else if (g_file_test ("/usr/lib/drv3.so.6.0", G_FILE_TEST_EXISTS))
+ path = "/usr/lib/drv3.so.6.0";
+ else
+ goto no_known_libraries;
+ break;
+ }
+ case GST_REAL_VIDEO_DEC_VERSION_4:
+ {
+ if (dec->path_rv40)
+ path = dec->path_rv40;
+ else if (g_file_test (DEFAULT_PATH_RV40, G_FILE_TEST_EXISTS))
+ path = DEFAULT_PATH_RV40;
+ else if (g_file_test ("/usr/lib/drv4.so.6.0", G_FILE_TEST_EXISTS))
+ path = "/usr/lib/drv4.so.6.0";
+ else
+ goto no_known_libraries;
+ break;
+ }
+ default:
+ goto unknown_version;
+ }
+
+ /* First close any open library */
+ close_library (dec);
+
+ dec->handle = dlopen (path, RTLD_LAZY);
+ if (!dec->handle)
+ goto could_not_open;
+
+ /* First try opening legacy symbols */
+ dec->custom_message = dlsym (dec->handle, "RV20toYUV420CustomMessage");
+ dec->free = dlsym (dec->handle, "RV20toYUV420Free");
+ dec->init = dlsym (dec->handle, "RV20toYUV420Init");
+ dec->transform = dlsym (dec->handle, "RV20toYUV420Transform");
+
+ if (!(dec->custom_message && dec->free && dec->init && dec->transform)) {
+ /* Else try loading new symbols */
+ dec->custom_message = dlsym (dec->handle, "RV40toYUV420CustomMessage");
+ dec->free = dlsym (dec->handle, "RV40toYUV420Free");
+ dec->init = dlsym (dec->handle, "RV40toYUV420Init");
+ dec->transform = dlsym (dec->handle, "RV40toYUV420Transform");
+
+ if (!(dec->custom_message && dec->free && dec->init && dec->transform))
+ goto could_not_load;
+ }
+
+ return TRUE;
+
+no_known_libraries:
+ {
+ GST_ELEMENT_ERROR (dec, LIBRARY, INIT,
+ ("Couldn't find a realvideo shared library for version %d",
+ dec->version), (NULL));
+ return FALSE;
+ }
+
+unknown_version:
+ {
+ GST_ERROR_OBJECT (dec, "Cannot handle version %i.", dec->version);
+ return FALSE;
+ }
+
+could_not_open:
+ {
+ GST_ERROR_OBJECT (dec, "Could not open library '%s'.", path);
+ return FALSE;
+ }
+
+could_not_load:
+ {
+ close_library (dec);
+ GST_ERROR_OBJECT (dec, "Could not load all symbols.");
+ return FALSE;
+ }
+}
+
+static void
+close_library (GstRealVideoDec * dec)
+{
+ if (dec->context && dec->free) {
+ dec->free (dec->context);
+ dec->context = NULL;
+ }
+
+ dec->custom_message = NULL;
+ dec->free = NULL;
+ dec->init = NULL;
+ dec->transform = NULL;
+
+ if (dec->handle)
+ dlclose (dec->handle);
+ dec->handle = NULL;
+}
+
+static void
+gst_real_video_dec_init (GstRealVideoDec * dec, GstRealVideoDecClass * klass)
+{
+ dec->snk =
+ gst_pad_new_from_template (gst_static_pad_template_get (&snk_t), "sink");
+ gst_pad_set_setcaps_function (dec->snk, gst_real_video_dec_setcaps);
+ gst_pad_set_chain_function (dec->snk, gst_real_video_dec_chain);
+ gst_pad_set_activatepush_function (dec->snk,
+ gst_real_video_dec_activate_push);
+ gst_element_add_pad (GST_ELEMENT (dec), dec->snk);
+
+ dec->src =
+ gst_pad_new_from_template (gst_static_pad_template_get (&src_t), "src");
+ gst_element_add_pad (GST_ELEMENT (dec), dec->src);
+
+ dec->adapter = g_object_new (GST_TYPE_ADAPTER, NULL);
+}
+
+static void
+gst_real_video_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_details (ec, &realvideode_details);
+}
+
+static void
+gst_real_video_dec_finalize (GObject * object)
+{
+ GstRealVideoDec *dec = GST_REAL_VIDEO_DEC (object);
+
+ if (dec->adapter) {
+ g_object_unref (G_OBJECT (dec->adapter));
+ dec->adapter = NULL;
+ }
+
+ close_library (dec);
+
+ if (dec->path_rv20) {
+ g_free (dec->path_rv20);
+ dec->path_rv20 = NULL;
+ }
+ if (dec->path_rv30) {
+ g_free (dec->path_rv30);
+ dec->path_rv30 = NULL;
+ }
+ if (dec->path_rv40) {
+ g_free (dec->path_rv40);
+ dec->path_rv40 = NULL;
+ }
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gst_real_video_dec_set_property (GObject * object, guint prop_id,
+ const GValue * value, GParamSpec * pspec)
+{
+ GstRealVideoDec *dec = GST_REAL_VIDEO_DEC (object);
+
+ /* Changing the location of the .so supposes it's not being done
+ * in a state greater than READY !
+ */
+
+ switch (prop_id) {
+ case PROP_PATH_RV20:
+ if (dec->path_rv20)
+ g_free (dec->path_rv20);
+ dec->path_rv20 = g_value_dup_string (value);
+ break;
+ case PROP_PATH_RV30:
+ if (dec->path_rv30)
+ g_free (dec->path_rv30);
+ dec->path_rv30 = g_value_dup_string (value);
+ break;
+ case PROP_PATH_RV40:
+ if (dec->path_rv40)
+ g_free (dec->path_rv40);
+ dec->path_rv40 = g_value_dup_string (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_real_video_dec_get_property (GObject * object, guint prop_id,
+ GValue * value, GParamSpec * pspec)
+{
+ GstRealVideoDec *dec = GST_REAL_VIDEO_DEC (object);
+
+ switch (prop_id) {
+ case PROP_PATH_RV20:
+ g_value_set_string (value, dec->path_rv20 ? dec->path_rv20 :
+ DEFAULT_PATH_RV20);
+ break;
+ case PROP_PATH_RV30:
+ g_value_set_string (value, dec->path_rv30 ? dec->path_rv30 :
+ DEFAULT_PATH_RV30);
+ break;
+ case PROP_PATH_RV40:
+ g_value_set_string (value, dec->path_rv40 ? dec->path_rv40 :
+ DEFAULT_PATH_RV40);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gst_real_video_dec_class_init (GstRealVideoDecClass * klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+ object_class->set_property = gst_real_video_dec_set_property;
+ object_class->get_property = gst_real_video_dec_get_property;
+ object_class->finalize = gst_real_video_dec_finalize;
+
+ g_object_class_install_property (object_class, PROP_PATH_RV20,
+ g_param_spec_string ("path_rv20", "Path to rv20 driver",
+ "Path to rv20 driver", DEFAULT_PATH_RV20, G_PARAM_READWRITE));
+ g_object_class_install_property (object_class, PROP_PATH_RV30,
+ g_param_spec_string ("path_rv30", "Path to rv30 driver",
+ "Path to rv30 driver", DEFAULT_PATH_RV30, G_PARAM_READWRITE));
+ g_object_class_install_property (object_class, PROP_PATH_RV40,
+ g_param_spec_string ("path_rv40", "Path to rv40 driver",
+ "Path to rv40 driver", DEFAULT_PATH_RV40, G_PARAM_READWRITE));
+
+ GST_DEBUG_CATEGORY_INIT (realvideode_debug, "realvideodec", 0,
+ "RealVideo decoder");
+}