| /* GStreamer |
| * Copyright (C) <2005,2006> Wim Taymans <wim@fluendo.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., 51 Franklin St, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| /* Element-Checklist-Version: 5 */ |
| |
| /** |
| * SECTION:element-rtspreal |
| * |
| * A RealMedia RTSP extension |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #ifdef HAVE_STDINT_H |
| #include <stdint.h> |
| #endif |
| |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <gst/rtsp/gstrtspextension.h> |
| |
| #include "realhash.h" |
| #include "rtspreal.h" |
| #include "asmrules.h" |
| |
| GST_DEBUG_CATEGORY_STATIC (rtspreal_debug); |
| #define GST_CAT_DEFAULT (rtspreal_debug) |
| |
| #define SERVER_PREFIX "RealServer" |
| #define DEFAULT_BANDWIDTH "10485800" |
| |
| static GstRTSPResult |
| rtsp_ext_real_get_transports (GstRTSPExtension * ext, |
| GstRTSPLowerTrans protocols, gchar ** transport) |
| { |
| GstRTSPReal *ctx = (GstRTSPReal *) ext; |
| GString *str; |
| |
| if (!ctx->isreal) |
| return GST_RTSP_OK; |
| |
| GST_DEBUG_OBJECT (ext, "generating transports for %d", protocols); |
| |
| str = g_string_new (""); |
| |
| /* |
| if (protocols & GST_RTSP_LOWER_TRANS_UDP_MCAST) { |
| g_string_append (str, "x-real-rdt/mcast;client_port=%%u1;mode=play,"); |
| } |
| if (protocols & GST_RTSP_LOWER_TRANS_UDP) { |
| g_string_append (str, "x-real-rdt/udp;client_port=%%u1;mode=play,"); |
| g_string_append (str, "x-pn-tng/udp;client_port=%%u1;mode=play,"); |
| } |
| */ |
| if (protocols & GST_RTSP_LOWER_TRANS_TCP) { |
| g_string_append (str, "x-real-rdt/tcp;mode=play,"); |
| g_string_append (str, "x-pn-tng/tcp;mode=play,"); |
| } |
| |
| /* if we added something, remove trailing ',' */ |
| if (str->len > 0) |
| g_string_truncate (str, str->len - 1); |
| |
| *transport = g_string_free (str, FALSE); |
| |
| return GST_RTSP_OK; |
| } |
| |
| static GstRTSPResult |
| rtsp_ext_real_before_send (GstRTSPExtension * ext, GstRTSPMessage * request) |
| { |
| GstRTSPReal *ctx = (GstRTSPReal *) ext; |
| |
| switch (request->type_data.request.method) { |
| case GST_RTSP_OPTIONS: |
| { |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_USER_AGENT, |
| //"RealMedia Player (" GST_PACKAGE_NAME ")"); |
| "RealMedia Player Version 6.0.9.1235 (linux-2.0-libc6-i386-gcc2.95)"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_CLIENT_CHALLENGE, |
| "9e26d33f2984236010ef6253fb1887f7"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_COMPANY_ID, |
| "KnKV4M4I/B2FjJ1TToLycw=="); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_GUID, |
| "00000000-0000-0000-0000-000000000000"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_REGION_DATA, "0"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_PLAYER_START_TIME, |
| "[28/03/2003:22:50:23 00:00]"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_CLIENT_ID, |
| "Linux_2.4_6.0.9.1235_play32_RN01_EN_586"); |
| ctx->isreal = FALSE; |
| break; |
| } |
| case GST_RTSP_DESCRIBE: |
| { |
| if (ctx->isreal) { |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_BANDWIDTH, |
| DEFAULT_BANDWIDTH); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_GUID, |
| "00000000-0000-0000-0000-000000000000"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_REGION_DATA, "0"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_CLIENT_ID, |
| "Linux_2.4_6.0.9.1235_play32_RN01_EN_586"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_MAX_ASM_WIDTH, "1"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_LANGUAGE, "en-US"); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_REQUIRE, |
| "com.real.retain-entity-for-setup"); |
| } |
| break; |
| } |
| case GST_RTSP_SETUP: |
| { |
| if (ctx->isreal) { |
| gchar *value = |
| g_strdup_printf ("%s, sd=%s", ctx->challenge2, ctx->checksum); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_REAL_CHALLENGE2, |
| value); |
| gst_rtsp_message_add_header (request, GST_RTSP_HDR_IF_MATCH, ctx->etag); |
| g_free (value); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| return GST_RTSP_OK; |
| } |
| |
| static GstRTSPResult |
| rtsp_ext_real_after_send (GstRTSPExtension * ext, GstRTSPMessage * req, |
| GstRTSPMessage * resp) |
| { |
| GstRTSPReal *ctx = (GstRTSPReal *) ext; |
| |
| switch (req->type_data.request.method) { |
| case GST_RTSP_OPTIONS: |
| { |
| gchar *challenge1 = NULL; |
| gchar *server = NULL; |
| |
| gst_rtsp_message_get_header (resp, GST_RTSP_HDR_SERVER, &server, 0); |
| |
| gst_rtsp_message_get_header (resp, GST_RTSP_HDR_REAL_CHALLENGE1, |
| &challenge1, 0); |
| if (!challenge1) |
| goto no_challenge1; |
| |
| gst_rtsp_ext_real_calc_response_and_checksum (ctx->challenge2, |
| ctx->checksum, challenge1); |
| |
| GST_DEBUG_OBJECT (ctx, "Found Real challenge tag"); |
| ctx->isreal = TRUE; |
| break; |
| } |
| case GST_RTSP_DESCRIBE: |
| { |
| gchar *etag = NULL; |
| guint len; |
| |
| gst_rtsp_message_get_header (resp, GST_RTSP_HDR_ETAG, &etag, 0); |
| if (etag) { |
| len = sizeof (ctx->etag); |
| strncpy (ctx->etag, etag, len); |
| ctx->etag[len - 1] = '\0'; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| return GST_RTSP_OK; |
| |
| /* ERRORS */ |
| no_challenge1: |
| { |
| GST_DEBUG_OBJECT (ctx, "Could not find challenge tag."); |
| ctx->isreal = FALSE; |
| return GST_RTSP_OK; |
| } |
| } |
| |
| #define ENSURE_SIZE(size) \ |
| G_STMT_START { \ |
| while (data_len < size) { \ |
| data_len += 1024; \ |
| data = g_realloc (data, data_len); \ |
| } \ |
| } G_STMT_END |
| |
| #define READ_BUFFER_GEN(src, func, name, dest, dest_len) \ |
| G_STMT_START { \ |
| dest = (gchar *)func (src, name); \ |
| dest_len = 0; \ |
| if (!dest) { \ |
| dest = (char *) ""; \ |
| } \ |
| else if (!strncmp (dest, "buffer;\"", 8)) { \ |
| dest += 8; \ |
| dest_len = strlen (dest) - 1; \ |
| dest[dest_len] = '\0'; \ |
| g_base64_decode_inplace (dest, &dest_len); \ |
| } \ |
| } G_STMT_END |
| |
| #define READ_BUFFER(sdp, name, dest, dest_len) \ |
| READ_BUFFER_GEN(sdp, gst_sdp_message_get_attribute_val, name, dest, dest_len) |
| #define READ_BUFFER_M(media, name, dest, dest_len) \ |
| READ_BUFFER_GEN(media, gst_sdp_media_get_attribute_val, name, dest, dest_len) |
| |
| #define READ_INT_GEN(src, func, name, dest) \ |
| G_STMT_START { \ |
| const gchar *val = func (src, name); \ |
| if (val && !strncmp (val, "integer;", 8)) \ |
| dest = atoi (val + 8); \ |
| else \ |
| dest = 0; \ |
| } G_STMT_END |
| |
| #define READ_INT(sdp, name, dest) \ |
| READ_INT_GEN(sdp, gst_sdp_message_get_attribute_val, name, dest) |
| #define READ_INT_M(media, name, dest) \ |
| READ_INT_GEN(media, gst_sdp_media_get_attribute_val, name, dest) |
| |
| #define READ_STRING(media, name, dest, dest_len) \ |
| G_STMT_START { \ |
| const gchar *val = gst_sdp_media_get_attribute_val (media, name); \ |
| if (val && !strncmp (val, "string;\"", 8)) { \ |
| dest = (gchar *) val + 8; \ |
| dest_len = strlen (dest) - 1; \ |
| dest[dest_len] = '\0'; \ |
| } else { \ |
| dest = (char *) ""; \ |
| dest_len = 0; \ |
| } \ |
| } G_STMT_END |
| |
| #define WRITE_STRING1(datap, str, str_len) \ |
| G_STMT_START { \ |
| *datap = str_len; \ |
| memcpy ((datap) + 1, str, str_len); \ |
| datap += str_len + 1; \ |
| } G_STMT_END |
| |
| #define WRITE_STRING2(datap, str, str_len) \ |
| G_STMT_START { \ |
| GST_WRITE_UINT16_BE (datap, str_len); \ |
| memcpy (datap + 2, str, str_len); \ |
| datap += str_len + 2; \ |
| } G_STMT_END |
| |
| static GstRTSPResult |
| rtsp_ext_real_parse_sdp (GstRTSPExtension * ext, GstSDPMessage * sdp, |
| GstStructure * props) |
| { |
| GstRTSPReal *ctx = (GstRTSPReal *) ext; |
| guint size; |
| gint i; |
| gchar *title, *author, *copyright, *comment; |
| gsize title_len, author_len, copyright_len, comment_len; |
| guint8 *data = NULL, *datap; |
| guint data_len = 0, offset; |
| GstBuffer *buf; |
| gchar *opaque_data; |
| gsize opaque_data_len, asm_rule_book_len; |
| GHashTable *vars; |
| GString *rules; |
| |
| /* don't bother for non-real formats */ |
| READ_INT (sdp, "IsRealDataType", ctx->isreal); |
| if (!ctx->isreal) |
| return TRUE; |
| |
| /* Force PAUSE | PLAY */ |
| //src->methods |= GST_RTSP_PLAY | GST_RTSP_PAUSE; |
| |
| ctx->n_streams = gst_sdp_message_medias_len (sdp); |
| |
| ctx->max_bit_rate = 0; |
| ctx->avg_bit_rate = 0; |
| ctx->max_packet_size = 0; |
| ctx->avg_packet_size = 0; |
| ctx->duration = 0; |
| |
| for (i = 0; i < ctx->n_streams; i++) { |
| const GstSDPMedia *media; |
| gint intval; |
| |
| media = gst_sdp_message_get_media (sdp, i); |
| |
| READ_INT_M (media, "MaxBitRate", intval); |
| ctx->max_bit_rate += intval; |
| READ_INT_M (media, "AvgBitRate", intval); |
| ctx->avg_bit_rate += intval; |
| READ_INT_M (media, "MaxPacketSize", intval); |
| ctx->max_packet_size = MAX (ctx->max_packet_size, intval); |
| READ_INT_M (media, "AvgPacketSize", intval); |
| ctx->avg_packet_size = (ctx->avg_packet_size * i + intval) / (i + 1); |
| READ_INT_M (media, "Duration", intval); |
| ctx->duration = MAX (ctx->duration, intval); |
| } |
| |
| /* FIXME: use GstByteWriter to write the header */ |
| /* PROP */ |
| offset = 0; |
| size = 50; |
| ENSURE_SIZE (size); |
| datap = data + offset; |
| |
| memcpy (datap + 0, "PROP", 4); |
| GST_WRITE_UINT32_BE (datap + 4, size); |
| GST_WRITE_UINT16_BE (datap + 8, 0); |
| GST_WRITE_UINT32_BE (datap + 10, ctx->max_bit_rate); |
| GST_WRITE_UINT32_BE (datap + 14, ctx->avg_bit_rate); |
| GST_WRITE_UINT32_BE (datap + 18, ctx->max_packet_size); |
| GST_WRITE_UINT32_BE (datap + 22, ctx->avg_packet_size); |
| GST_WRITE_UINT32_BE (datap + 26, 0); |
| GST_WRITE_UINT32_BE (datap + 30, ctx->duration); |
| GST_WRITE_UINT32_BE (datap + 34, 0); |
| GST_WRITE_UINT32_BE (datap + 38, 0); |
| GST_WRITE_UINT32_BE (datap + 42, 0); |
| GST_WRITE_UINT16_BE (datap + 46, ctx->n_streams); |
| GST_WRITE_UINT16_BE (datap + 48, 0); |
| offset += size; |
| |
| /* CONT */ |
| READ_BUFFER (sdp, "Title", title, title_len); |
| READ_BUFFER (sdp, "Author", author, author_len); |
| READ_BUFFER (sdp, "Comment", comment, comment_len); |
| READ_BUFFER (sdp, "Copyright", copyright, copyright_len); |
| |
| size = 18 + title_len + author_len + comment_len + copyright_len; |
| ENSURE_SIZE (offset + size); |
| datap = data + offset; |
| |
| memcpy (datap, "CONT", 4); |
| GST_WRITE_UINT32_BE (datap + 4, size); |
| GST_WRITE_UINT16_BE (datap + 8, 0); /* Version */ |
| datap += 10; |
| WRITE_STRING2 (datap, title, title_len); |
| WRITE_STRING2 (datap, author, author_len); |
| WRITE_STRING2 (datap, copyright, copyright_len); |
| WRITE_STRING2 (datap, comment, comment_len); |
| offset += size; |
| |
| /* fix the hashtale for the rule parser */ |
| rules = g_string_new (""); |
| vars = g_hash_table_new (g_str_hash, g_str_equal); |
| g_hash_table_insert (vars, (gchar *) "Bandwidth", |
| (gchar *) DEFAULT_BANDWIDTH); |
| |
| /* MDPR */ |
| for (i = 0; i < ctx->n_streams; i++) { |
| const GstSDPMedia *media; |
| guint32 len; |
| GstRTSPRealStream *stream; |
| gchar *str; |
| gint rulematches[MAX_RULEMATCHES]; |
| gint sel, j, n; |
| |
| media = gst_sdp_message_get_media (sdp, i); |
| |
| if (media->media && !strcmp (media->media, "data")) |
| continue; |
| |
| stream = g_new0 (GstRTSPRealStream, 1); |
| ctx->streams = g_list_append (ctx->streams, stream); |
| |
| READ_INT_M (media, "MaxBitRate", stream->max_bit_rate); |
| READ_INT_M (media, "AvgBitRate", stream->avg_bit_rate); |
| READ_INT_M (media, "MaxPacketSize", stream->max_packet_size); |
| READ_INT_M (media, "AvgPacketSize", stream->avg_packet_size); |
| READ_INT_M (media, "StartTime", stream->start_time); |
| READ_INT_M (media, "Preroll", stream->preroll); |
| READ_INT_M (media, "Duration", stream->duration); |
| READ_STRING (media, "StreamName", str, stream->stream_name_len); |
| stream->stream_name = g_strndup (str, stream->stream_name_len); |
| READ_STRING (media, "mimetype", str, stream->mime_type_len); |
| stream->mime_type = g_strndup (str, stream->mime_type_len); |
| |
| /* FIXME: Depending on the current bandwidth, we need to select one |
| * bandwith out of a list offered by the server. Someone needs to write |
| * a parser for strings like |
| * |
| * #($Bandwidth < 67959),TimestampDelivery=T,DropByN=T,priority=9; |
| * #($Bandwidth >= 67959) && ($Bandwidth < 167959),AverageBandwidth=67959, |
| * Priority=9;#($Bandwidth >= 67959) && ($Bandwidth < 167959), |
| * AverageBandwidth=0,Priority=5,OnDepend=\"1\"; |
| * #($Bandwidth >= 167959) && ($Bandwidth < 267959), |
| * AverageBandwidth=167959,Priority=9; |
| * #($Bandwidth >= 167959) && ($Bandwidth < 267959),AverageBandwidth=0, |
| * Priority=5,OnDepend=\"3\";#($Bandwidth >= 267959), |
| * AverageBandwidth=267959,Priority=9;#($Bandwidth >= 267959), |
| * AverageBandwidth=0,Priority=5,OnDepend=\"5\"; |
| * |
| * As I don't know how to do that, I just use the first entry (sel = 0). |
| * But to give you a starting point, I offer you above string |
| * in the variable 'asm_rule_book'. |
| */ |
| READ_STRING (media, "ASMRuleBook", str, asm_rule_book_len); |
| stream->rulebook = gst_asm_rule_book_new (str); |
| |
| n = gst_asm_rule_book_match (stream->rulebook, vars, rulematches); |
| for (j = 0; j < n; j++) { |
| g_string_append_printf (rules, "stream=%u;rule=%u,", i, rulematches[j]); |
| } |
| |
| /* get the MLTI for the first matched rules */ |
| sel = rulematches[0]; |
| |
| READ_BUFFER_M (media, "OpaqueData", opaque_data, opaque_data_len); |
| |
| if (opaque_data_len < 4) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 4", |
| opaque_data_len); |
| goto strange_opaque_data; |
| } |
| if (strncmp (opaque_data, "MLTI", 4)) { |
| GST_DEBUG_OBJECT (ctx, "no MLTI found, appending all"); |
| stream->type_specific_data_len = opaque_data_len; |
| stream->type_specific_data = g_memdup (opaque_data, opaque_data_len); |
| goto no_type_specific; |
| } |
| opaque_data += 4; |
| opaque_data_len -= 4; |
| |
| if (opaque_data_len < 2) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 2", |
| opaque_data_len); |
| goto strange_opaque_data; |
| } |
| stream->num_rules = GST_READ_UINT16_BE (opaque_data); |
| opaque_data += 2; |
| opaque_data_len -= 2; |
| |
| if (sel >= stream->num_rules) { |
| GST_DEBUG_OBJECT (ctx, "sel %d >= num_rules %d", sel, stream->num_rules); |
| goto strange_opaque_data; |
| } |
| |
| if (opaque_data_len < 2 * sel) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT |
| " < 2 * sel (%d)", opaque_data_len, 2 * sel); |
| goto strange_opaque_data; |
| } |
| opaque_data += 2 * sel; |
| opaque_data_len -= 2 * sel; |
| |
| if (opaque_data_len < 2) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 2", |
| opaque_data_len); |
| goto strange_opaque_data; |
| } |
| stream->codec = GST_READ_UINT16_BE (opaque_data); |
| opaque_data += 2; |
| opaque_data_len -= 2; |
| |
| if (opaque_data_len < 2 * (stream->num_rules - sel - 1)) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT |
| " < %d", opaque_data_len, 2 * (stream->num_rules - sel - 1)); |
| goto strange_opaque_data; |
| } |
| opaque_data += 2 * (stream->num_rules - sel - 1); |
| opaque_data_len -= 2 * (stream->num_rules - sel - 1); |
| |
| if (opaque_data_len < 2) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 2", |
| opaque_data_len); |
| goto strange_opaque_data; |
| } |
| stream->num_rules = GST_READ_UINT16_BE (opaque_data); |
| opaque_data += 2; |
| opaque_data_len -= 2; |
| |
| if (stream->codec > stream->num_rules) { |
| GST_DEBUG_OBJECT (ctx, "codec %d > num_rules %d", stream->codec, |
| stream->num_rules); |
| goto strange_opaque_data; |
| } |
| |
| for (j = 0; j < stream->codec; j++) { |
| if (opaque_data_len < 4) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 4", |
| opaque_data_len); |
| goto strange_opaque_data; |
| } |
| len = GST_READ_UINT32_BE (opaque_data); |
| opaque_data += 4; |
| opaque_data_len -= 4; |
| |
| if (opaque_data_len < len) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < len %d", |
| opaque_data_len, len); |
| goto strange_opaque_data; |
| } |
| opaque_data += len; |
| opaque_data_len -= len; |
| } |
| |
| if (opaque_data_len < 4) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 4", |
| opaque_data_len); |
| goto strange_opaque_data; |
| } |
| stream->type_specific_data_len = GST_READ_UINT32_BE (opaque_data); |
| opaque_data += 4; |
| opaque_data_len -= 4; |
| |
| if (opaque_data_len < stream->type_specific_data_len) { |
| GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < %d", |
| opaque_data_len, stream->type_specific_data_len); |
| goto strange_opaque_data; |
| } |
| stream->type_specific_data = |
| g_memdup (opaque_data, stream->type_specific_data_len); |
| |
| no_type_specific: |
| size = |
| 46 + stream->stream_name_len + stream->mime_type_len + |
| stream->type_specific_data_len; |
| ENSURE_SIZE (offset + size); |
| datap = data + offset; |
| |
| memcpy (datap, "MDPR", 4); |
| GST_WRITE_UINT32_BE (datap + 4, size); |
| GST_WRITE_UINT16_BE (datap + 8, 0); |
| GST_WRITE_UINT16_BE (datap + 10, i); |
| GST_WRITE_UINT32_BE (datap + 12, stream->max_bit_rate); |
| GST_WRITE_UINT32_BE (datap + 16, stream->avg_bit_rate); |
| GST_WRITE_UINT32_BE (datap + 20, stream->max_packet_size); |
| GST_WRITE_UINT32_BE (datap + 24, stream->avg_packet_size); |
| GST_WRITE_UINT32_BE (datap + 28, stream->start_time); |
| GST_WRITE_UINT32_BE (datap + 32, stream->preroll); |
| GST_WRITE_UINT32_BE (datap + 36, stream->duration); |
| datap += 40; |
| WRITE_STRING1 (datap, stream->stream_name, stream->stream_name_len); |
| WRITE_STRING1 (datap, stream->mime_type, stream->mime_type_len); |
| GST_WRITE_UINT32_BE (datap, stream->type_specific_data_len); |
| if (stream->type_specific_data_len) |
| memcpy (datap + 4, stream->type_specific_data, |
| stream->type_specific_data_len); |
| offset += size; |
| } |
| |
| /* destroy the rulebook hashtable now */ |
| g_hash_table_destroy (vars); |
| |
| /* strip final , if we added some stream rules */ |
| if (rules->len > 0) { |
| rules = g_string_truncate (rules, rules->len - 1); |
| } |
| |
| /* and store rules in the context */ |
| ctx->rules = g_string_free (rules, FALSE); |
| |
| /* DATA */ |
| size = 18; |
| ENSURE_SIZE (offset + size); |
| datap = data + offset; |
| |
| memcpy (datap, "DATA", 4); |
| GST_WRITE_UINT32_BE (datap + 4, size); |
| GST_WRITE_UINT16_BE (datap + 8, 0); |
| GST_WRITE_UINT32_BE (datap + 10, 0); /* number of packets */ |
| GST_WRITE_UINT32_BE (datap + 14, 0); /* next data header */ |
| offset += size; |
| |
| buf = gst_buffer_new_wrapped (data, offset); |
| |
| /* Set on caps */ |
| GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER); |
| gst_structure_set (props, "config", GST_TYPE_BUFFER, buf, NULL); |
| gst_buffer_unref (buf); |
| |
| /* Overwrite encoding and media fields */ |
| gst_structure_set (props, "encoding-name", G_TYPE_STRING, "X-REAL-RDT", NULL); |
| gst_structure_set (props, "media", G_TYPE_STRING, "application", NULL); |
| |
| return TRUE; |
| |
| /* ERRORS */ |
| strange_opaque_data: |
| { |
| g_string_free (rules, TRUE); |
| g_hash_table_destroy (vars); |
| g_free (data); |
| |
| GST_ELEMENT_ERROR (ctx, RESOURCE, WRITE, ("Strange opaque data."), (NULL)); |
| return FALSE; |
| } |
| } |
| |
| static GstRTSPResult |
| rtsp_ext_real_stream_select (GstRTSPExtension * ext, GstRTSPUrl * url) |
| { |
| GstRTSPReal *ctx = (GstRTSPReal *) ext; |
| GstRTSPResult res; |
| GstRTSPMessage request = { 0 }; |
| GstRTSPMessage response = { 0 }; |
| gchar *req_url; |
| |
| if (!ctx->isreal) |
| return GST_RTSP_OK; |
| |
| if (!ctx->rules) |
| return GST_RTSP_OK; |
| |
| req_url = gst_rtsp_url_get_request_uri (url); |
| |
| /* create SET_PARAMETER */ |
| if ((res = gst_rtsp_message_init_request (&request, GST_RTSP_SET_PARAMETER, |
| req_url)) < 0) |
| goto create_request_failed; |
| |
| g_free (req_url); |
| |
| gst_rtsp_message_add_header (&request, GST_RTSP_HDR_SUBSCRIBE, ctx->rules); |
| |
| /* send SET_PARAMETER */ |
| if ((res = gst_rtsp_extension_send (ext, &request, &response)) < 0) |
| goto send_error; |
| |
| gst_rtsp_message_unset (&request); |
| gst_rtsp_message_unset (&response); |
| |
| return GST_RTSP_OK; |
| |
| /* ERRORS */ |
| create_request_failed: |
| { |
| GST_ELEMENT_ERROR (ctx, LIBRARY, INIT, |
| ("Could not create request."), (NULL)); |
| g_free (req_url); |
| goto reset; |
| } |
| send_error: |
| { |
| GST_ELEMENT_ERROR (ctx, RESOURCE, WRITE, |
| ("Could not send message."), (NULL)); |
| goto reset; |
| } |
| reset: |
| { |
| gst_rtsp_message_unset (&request); |
| gst_rtsp_message_unset (&response); |
| return res; |
| } |
| } |
| |
| static void gst_rtsp_real_extension_init (gpointer g_iface, |
| gpointer iface_data); |
| static void gst_rtsp_real_finalize (GObject * obj); |
| |
| #define gst_rtsp_real_parent_class parent_class |
| G_DEFINE_TYPE_WITH_CODE (GstRTSPReal, gst_rtsp_real, GST_TYPE_ELEMENT, |
| G_IMPLEMENT_INTERFACE (GST_TYPE_RTSP_EXTENSION, |
| gst_rtsp_real_extension_init)); |
| |
| static void |
| gst_rtsp_real_class_init (GstRTSPRealClass * g_class) |
| { |
| GObjectClass *gobject_class = (GObjectClass *) g_class; |
| GstElementClass *gstelement_class = (GstElementClass *) g_class; |
| |
| gobject_class->finalize = gst_rtsp_real_finalize; |
| |
| gst_element_class_set_static_metadata (gstelement_class, |
| "RealMedia RTSP Extension", "Network/Extension/Protocol", |
| "Extends RTSP so that it can handle RealMedia setup", |
| "Wim Taymans <wim.taymans@gmail.com>"); |
| |
| GST_DEBUG_CATEGORY_INIT (rtspreal_debug, "rtspreal", 0, |
| "RealMedia RTSP extension"); |
| } |
| |
| static void |
| gst_rtsp_real_init (GstRTSPReal * rtspreal) |
| { |
| rtspreal->isreal = FALSE; |
| } |
| |
| static void |
| gst_rtsp_stream_free (GstRTSPRealStream * stream) |
| { |
| g_free (stream->stream_name); |
| g_free (stream->mime_type); |
| gst_asm_rule_book_free (stream->rulebook); |
| g_free (stream->type_specific_data); |
| |
| g_free (stream); |
| } |
| |
| static void |
| gst_rtsp_real_finalize (GObject * obj) |
| { |
| GstRTSPReal *r = (GstRTSPReal *) obj; |
| |
| g_list_foreach (r->streams, (GFunc) gst_rtsp_stream_free, NULL); |
| g_list_free (r->streams); |
| g_free (r->rules); |
| |
| G_OBJECT_CLASS (parent_class)->finalize (obj); |
| } |
| |
| static void |
| gst_rtsp_real_extension_init (gpointer g_iface, gpointer iface_data) |
| { |
| GstRTSPExtensionInterface *iface = (GstRTSPExtensionInterface *) g_iface; |
| |
| iface->before_send = rtsp_ext_real_before_send; |
| iface->after_send = rtsp_ext_real_after_send; |
| iface->parse_sdp = rtsp_ext_real_parse_sdp; |
| iface->stream_select = rtsp_ext_real_stream_select; |
| iface->get_transports = rtsp_ext_real_get_transports; |
| } |
| |
| gboolean |
| gst_rtsp_real_plugin_init (GstPlugin * plugin) |
| { |
| return gst_element_register (plugin, "rtspreal", |
| GST_RANK_MARGINAL, GST_TYPE_RTSP_REAL); |
| } |
