1 /* GStreamer
2 * Copyright (C) <2005,2006> Wim Taymans <wim@fluendo.com>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19 /* Element-Checklist-Version: 5 */
20
21 /**
22 * SECTION:element-rtspreal
23 *
24 * A RealMedia RTSP extension
25 */
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #endif
30
31 #ifdef HAVE_STDINT_H
32 #include <stdint.h>
33 #endif
34
35 #include <stdlib.h>
36 #include <string.h>
37
38 #include <gst/rtsp/gstrtspextension.h>
39
40 #include "realhash.h"
41 #include "rtspreal.h"
42 #include "asmrules.h"
43
44 GST_DEBUG_CATEGORY_STATIC (rtspreal_debug);
45 #define GST_CAT_DEFAULT (rtspreal_debug)
46
47 #define SERVER_PREFIX "RealServer"
48 #define DEFAULT_BANDWIDTH "10485800"
49
50 static GstRTSPResult
rtsp_ext_real_get_transports(GstRTSPExtension * ext,GstRTSPLowerTrans protocols,gchar ** transport)51 rtsp_ext_real_get_transports (GstRTSPExtension * ext,
52 GstRTSPLowerTrans protocols, gchar ** transport)
53 {
54 GstRTSPReal *ctx = (GstRTSPReal *) ext;
55 GString *str;
56
57 if (!ctx->isreal)
58 return GST_RTSP_OK;
59
60 GST_DEBUG_OBJECT (ext, "generating transports for %d", protocols);
61
62 str = g_string_new ("");
63
64 /*
65 if (protocols & GST_RTSP_LOWER_TRANS_UDP_MCAST) {
66 g_string_append (str, "x-real-rdt/mcast;client_port=%%u1;mode=play,");
67 }
68 if (protocols & GST_RTSP_LOWER_TRANS_UDP) {
69 g_string_append (str, "x-real-rdt/udp;client_port=%%u1;mode=play,");
70 g_string_append (str, "x-pn-tng/udp;client_port=%%u1;mode=play,");
71 }
72 */
73 if (protocols & GST_RTSP_LOWER_TRANS_TCP) {
74 g_string_append (str, "x-real-rdt/tcp;mode=play,");
75 g_string_append (str, "x-pn-tng/tcp;mode=play,");
76 }
77
78 /* if we added something, remove trailing ',' */
79 if (str->len > 0)
80 g_string_truncate (str, str->len - 1);
81
82 *transport = g_string_free (str, FALSE);
83
84 return GST_RTSP_OK;
85 }
86
87 static GstRTSPResult
rtsp_ext_real_before_send(GstRTSPExtension * ext,GstRTSPMessage * request)88 rtsp_ext_real_before_send (GstRTSPExtension * ext, GstRTSPMessage * request)
89 {
90 GstRTSPReal *ctx = (GstRTSPReal *) ext;
91
92 switch (request->type_data.request.method) {
93 case GST_RTSP_OPTIONS:
94 {
95 gst_rtsp_message_add_header (request, GST_RTSP_HDR_USER_AGENT,
96 //"RealMedia Player (" GST_PACKAGE_NAME ")");
97 "RealMedia Player Version 6.0.9.1235 (linux-2.0-libc6-i386-gcc2.95)");
98 gst_rtsp_message_add_header (request, GST_RTSP_HDR_CLIENT_CHALLENGE,
99 "9e26d33f2984236010ef6253fb1887f7");
100 gst_rtsp_message_add_header (request, GST_RTSP_HDR_COMPANY_ID,
101 "KnKV4M4I/B2FjJ1TToLycw==");
102 gst_rtsp_message_add_header (request, GST_RTSP_HDR_GUID,
103 "00000000-0000-0000-0000-000000000000");
104 gst_rtsp_message_add_header (request, GST_RTSP_HDR_REGION_DATA, "0");
105 gst_rtsp_message_add_header (request, GST_RTSP_HDR_PLAYER_START_TIME,
106 "[28/03/2003:22:50:23 00:00]");
107 gst_rtsp_message_add_header (request, GST_RTSP_HDR_CLIENT_ID,
108 "Linux_2.4_6.0.9.1235_play32_RN01_EN_586");
109 ctx->isreal = FALSE;
110 break;
111 }
112 case GST_RTSP_DESCRIBE:
113 {
114 if (ctx->isreal) {
115 gst_rtsp_message_add_header (request, GST_RTSP_HDR_BANDWIDTH,
116 DEFAULT_BANDWIDTH);
117 gst_rtsp_message_add_header (request, GST_RTSP_HDR_GUID,
118 "00000000-0000-0000-0000-000000000000");
119 gst_rtsp_message_add_header (request, GST_RTSP_HDR_REGION_DATA, "0");
120 gst_rtsp_message_add_header (request, GST_RTSP_HDR_CLIENT_ID,
121 "Linux_2.4_6.0.9.1235_play32_RN01_EN_586");
122 gst_rtsp_message_add_header (request, GST_RTSP_HDR_MAX_ASM_WIDTH, "1");
123 gst_rtsp_message_add_header (request, GST_RTSP_HDR_LANGUAGE, "en-US");
124 gst_rtsp_message_add_header (request, GST_RTSP_HDR_REQUIRE,
125 "com.real.retain-entity-for-setup");
126 }
127 break;
128 }
129 case GST_RTSP_SETUP:
130 {
131 if (ctx->isreal) {
132 gchar *value =
133 g_strdup_printf ("%s, sd=%s", ctx->challenge2, ctx->checksum);
134 gst_rtsp_message_add_header (request, GST_RTSP_HDR_REAL_CHALLENGE2,
135 value);
136 gst_rtsp_message_add_header (request, GST_RTSP_HDR_IF_MATCH, ctx->etag);
137 g_free (value);
138 }
139 break;
140 }
141 default:
142 break;
143 }
144 return GST_RTSP_OK;
145 }
146
147 static GstRTSPResult
rtsp_ext_real_after_send(GstRTSPExtension * ext,GstRTSPMessage * req,GstRTSPMessage * resp)148 rtsp_ext_real_after_send (GstRTSPExtension * ext, GstRTSPMessage * req,
149 GstRTSPMessage * resp)
150 {
151 GstRTSPReal *ctx = (GstRTSPReal *) ext;
152
153 switch (req->type_data.request.method) {
154 case GST_RTSP_OPTIONS:
155 {
156 gchar *challenge1 = NULL;
157 gchar *server = NULL;
158
159 gst_rtsp_message_get_header (resp, GST_RTSP_HDR_SERVER, &server, 0);
160
161 gst_rtsp_message_get_header (resp, GST_RTSP_HDR_REAL_CHALLENGE1,
162 &challenge1, 0);
163 if (!challenge1)
164 goto no_challenge1;
165
166 gst_rtsp_ext_real_calc_response_and_checksum (ctx->challenge2,
167 ctx->checksum, challenge1);
168
169 GST_DEBUG_OBJECT (ctx, "Found Real challenge tag");
170 ctx->isreal = TRUE;
171 break;
172 }
173 case GST_RTSP_DESCRIBE:
174 {
175 gchar *etag = NULL;
176 guint len;
177
178 gst_rtsp_message_get_header (resp, GST_RTSP_HDR_ETAG, &etag, 0);
179 if (etag) {
180 len = sizeof (ctx->etag);
181 strncpy (ctx->etag, etag, len);
182 ctx->etag[len - 1] = '\0';
183 }
184 break;
185 }
186 default:
187 break;
188 }
189 return GST_RTSP_OK;
190
191 /* ERRORS */
192 no_challenge1:
193 {
194 GST_DEBUG_OBJECT (ctx, "Could not find challenge tag.");
195 ctx->isreal = FALSE;
196 return GST_RTSP_OK;
197 }
198 }
199
200 #define ENSURE_SIZE(size) \
201 G_STMT_START { \
202 while (data_len < size) { \
203 data_len += 1024; \
204 data = g_realloc (data, data_len); \
205 } \
206 } G_STMT_END
207
208 #define READ_BUFFER_GEN(src, func, name, dest, dest_len) \
209 G_STMT_START { \
210 dest = (gchar *)func (src, name); \
211 dest_len = 0; \
212 if (!dest) { \
213 dest = (char *) ""; \
214 } \
215 else if (!strncmp (dest, "buffer;\"", 8)) { \
216 dest += 8; \
217 dest_len = strlen (dest) - 1; \
218 dest[dest_len] = '\0'; \
219 g_base64_decode_inplace (dest, &dest_len); \
220 } \
221 } G_STMT_END
222
223 #define READ_BUFFER(sdp, name, dest, dest_len) \
224 READ_BUFFER_GEN(sdp, gst_sdp_message_get_attribute_val, name, dest, dest_len)
225 #define READ_BUFFER_M(media, name, dest, dest_len) \
226 READ_BUFFER_GEN(media, gst_sdp_media_get_attribute_val, name, dest, dest_len)
227
228 #define READ_INT_GEN(src, func, name, dest) \
229 G_STMT_START { \
230 const gchar *val = func (src, name); \
231 if (val && !strncmp (val, "integer;", 8)) \
232 dest = atoi (val + 8); \
233 else \
234 dest = 0; \
235 } G_STMT_END
236
237 #define READ_INT(sdp, name, dest) \
238 READ_INT_GEN(sdp, gst_sdp_message_get_attribute_val, name, dest)
239 #define READ_INT_M(media, name, dest) \
240 READ_INT_GEN(media, gst_sdp_media_get_attribute_val, name, dest)
241
242 #define READ_STRING(media, name, dest, dest_len) \
243 G_STMT_START { \
244 const gchar *val = gst_sdp_media_get_attribute_val (media, name); \
245 if (val && !strncmp (val, "string;\"", 8)) { \
246 dest = (gchar *) val + 8; \
247 dest_len = strlen (dest) - 1; \
248 dest[dest_len] = '\0'; \
249 } else { \
250 dest = (char *) ""; \
251 dest_len = 0; \
252 } \
253 } G_STMT_END
254
255 #define WRITE_STRING1(datap, str, str_len) \
256 G_STMT_START { \
257 *datap = str_len; \
258 memcpy ((datap) + 1, str, str_len); \
259 datap += str_len + 1; \
260 } G_STMT_END
261
262 #define WRITE_STRING2(datap, str, str_len) \
263 G_STMT_START { \
264 GST_WRITE_UINT16_BE (datap, str_len); \
265 memcpy (datap + 2, str, str_len); \
266 datap += str_len + 2; \
267 } G_STMT_END
268
269 static GstRTSPResult
rtsp_ext_real_parse_sdp(GstRTSPExtension * ext,GstSDPMessage * sdp,GstStructure * props)270 rtsp_ext_real_parse_sdp (GstRTSPExtension * ext, GstSDPMessage * sdp,
271 GstStructure * props)
272 {
273 GstRTSPReal *ctx = (GstRTSPReal *) ext;
274 guint size;
275 gint i;
276 gchar *title, *author, *copyright, *comment;
277 gsize title_len, author_len, copyright_len, comment_len;
278 guint8 *data = NULL, *datap;
279 guint data_len = 0, offset;
280 GstBuffer *buf;
281 gchar *opaque_data;
282 gsize opaque_data_len, asm_rule_book_len;
283 GHashTable *vars;
284 GString *rules;
285
286 /* don't bother for non-real formats */
287 READ_INT (sdp, "IsRealDataType", ctx->isreal);
288 if (!ctx->isreal)
289 return TRUE;
290
291 /* Force PAUSE | PLAY */
292 //src->methods |= GST_RTSP_PLAY | GST_RTSP_PAUSE;
293
294 ctx->n_streams = gst_sdp_message_medias_len (sdp);
295
296 ctx->max_bit_rate = 0;
297 ctx->avg_bit_rate = 0;
298 ctx->max_packet_size = 0;
299 ctx->avg_packet_size = 0;
300 ctx->duration = 0;
301
302 for (i = 0; i < ctx->n_streams; i++) {
303 const GstSDPMedia *media;
304 gint intval;
305
306 media = gst_sdp_message_get_media (sdp, i);
307
308 READ_INT_M (media, "MaxBitRate", intval);
309 ctx->max_bit_rate += intval;
310 READ_INT_M (media, "AvgBitRate", intval);
311 ctx->avg_bit_rate += intval;
312 READ_INT_M (media, "MaxPacketSize", intval);
313 ctx->max_packet_size = MAX (ctx->max_packet_size, intval);
314 READ_INT_M (media, "AvgPacketSize", intval);
315 ctx->avg_packet_size = (ctx->avg_packet_size * i + intval) / (i + 1);
316 READ_INT_M (media, "Duration", intval);
317 ctx->duration = MAX (ctx->duration, intval);
318 }
319
320 /* FIXME: use GstByteWriter to write the header */
321 /* PROP */
322 offset = 0;
323 size = 50;
324 ENSURE_SIZE (size);
325 datap = data + offset;
326
327 memcpy (datap + 0, "PROP", 4);
328 GST_WRITE_UINT32_BE (datap + 4, size);
329 GST_WRITE_UINT16_BE (datap + 8, 0);
330 GST_WRITE_UINT32_BE (datap + 10, ctx->max_bit_rate);
331 GST_WRITE_UINT32_BE (datap + 14, ctx->avg_bit_rate);
332 GST_WRITE_UINT32_BE (datap + 18, ctx->max_packet_size);
333 GST_WRITE_UINT32_BE (datap + 22, ctx->avg_packet_size);
334 GST_WRITE_UINT32_BE (datap + 26, 0);
335 GST_WRITE_UINT32_BE (datap + 30, ctx->duration);
336 GST_WRITE_UINT32_BE (datap + 34, 0);
337 GST_WRITE_UINT32_BE (datap + 38, 0);
338 GST_WRITE_UINT32_BE (datap + 42, 0);
339 GST_WRITE_UINT16_BE (datap + 46, ctx->n_streams);
340 GST_WRITE_UINT16_BE (datap + 48, 0);
341 offset += size;
342
343 /* CONT */
344 READ_BUFFER (sdp, "Title", title, title_len);
345 READ_BUFFER (sdp, "Author", author, author_len);
346 READ_BUFFER (sdp, "Comment", comment, comment_len);
347 READ_BUFFER (sdp, "Copyright", copyright, copyright_len);
348
349 size = 18 + title_len + author_len + comment_len + copyright_len;
350 ENSURE_SIZE (offset + size);
351 datap = data + offset;
352
353 memcpy (datap, "CONT", 4);
354 GST_WRITE_UINT32_BE (datap + 4, size);
355 GST_WRITE_UINT16_BE (datap + 8, 0); /* Version */
356 datap += 10;
357 WRITE_STRING2 (datap, title, title_len);
358 WRITE_STRING2 (datap, author, author_len);
359 WRITE_STRING2 (datap, copyright, copyright_len);
360 WRITE_STRING2 (datap, comment, comment_len);
361 offset += size;
362
363 /* fix the hashtale for the rule parser */
364 rules = g_string_new ("");
365 vars = g_hash_table_new (g_str_hash, g_str_equal);
366 g_hash_table_insert (vars, (gchar *) "Bandwidth",
367 (gchar *) DEFAULT_BANDWIDTH);
368
369 /* MDPR */
370 for (i = 0; i < ctx->n_streams; i++) {
371 const GstSDPMedia *media;
372 guint32 len;
373 GstRTSPRealStream *stream;
374 gchar *str;
375 gint rulematches[MAX_RULEMATCHES];
376 gint sel, j, n;
377
378 media = gst_sdp_message_get_media (sdp, i);
379
380 if (media->media && !strcmp (media->media, "data"))
381 continue;
382
383 stream = g_new0 (GstRTSPRealStream, 1);
384 ctx->streams = g_list_append (ctx->streams, stream);
385
386 READ_INT_M (media, "MaxBitRate", stream->max_bit_rate);
387 READ_INT_M (media, "AvgBitRate", stream->avg_bit_rate);
388 READ_INT_M (media, "MaxPacketSize", stream->max_packet_size);
389 READ_INT_M (media, "AvgPacketSize", stream->avg_packet_size);
390 READ_INT_M (media, "StartTime", stream->start_time);
391 READ_INT_M (media, "Preroll", stream->preroll);
392 READ_INT_M (media, "Duration", stream->duration);
393 READ_STRING (media, "StreamName", str, stream->stream_name_len);
394 stream->stream_name = g_strndup (str, stream->stream_name_len);
395 READ_STRING (media, "mimetype", str, stream->mime_type_len);
396 stream->mime_type = g_strndup (str, stream->mime_type_len);
397
398 /* FIXME: Depending on the current bandwidth, we need to select one
399 * bandwith out of a list offered by the server. Someone needs to write
400 * a parser for strings like
401 *
402 * #($Bandwidth < 67959),TimestampDelivery=T,DropByN=T,priority=9;
403 * #($Bandwidth >= 67959) && ($Bandwidth < 167959),AverageBandwidth=67959,
404 * Priority=9;#($Bandwidth >= 67959) && ($Bandwidth < 167959),
405 * AverageBandwidth=0,Priority=5,OnDepend=\"1\";
406 * #($Bandwidth >= 167959) && ($Bandwidth < 267959),
407 * AverageBandwidth=167959,Priority=9;
408 * #($Bandwidth >= 167959) && ($Bandwidth < 267959),AverageBandwidth=0,
409 * Priority=5,OnDepend=\"3\";#($Bandwidth >= 267959),
410 * AverageBandwidth=267959,Priority=9;#($Bandwidth >= 267959),
411 * AverageBandwidth=0,Priority=5,OnDepend=\"5\";
412 *
413 * As I don't know how to do that, I just use the first entry (sel = 0).
414 * But to give you a starting point, I offer you above string
415 * in the variable 'asm_rule_book'.
416 */
417 READ_STRING (media, "ASMRuleBook", str, asm_rule_book_len);
418 stream->rulebook = gst_asm_rule_book_new (str);
419
420 n = gst_asm_rule_book_match (stream->rulebook, vars, rulematches);
421 for (j = 0; j < n; j++) {
422 g_string_append_printf (rules, "stream=%u;rule=%u,", i, rulematches[j]);
423 }
424
425 /* get the MLTI for the first matched rules */
426 sel = rulematches[0];
427
428 READ_BUFFER_M (media, "OpaqueData", opaque_data, opaque_data_len);
429
430 if (opaque_data_len < 4) {
431 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 4",
432 opaque_data_len);
433 goto strange_opaque_data;
434 }
435 if (strncmp (opaque_data, "MLTI", 4)) {
436 GST_DEBUG_OBJECT (ctx, "no MLTI found, appending all");
437 stream->type_specific_data_len = opaque_data_len;
438 stream->type_specific_data = g_memdup (opaque_data, opaque_data_len);
439 goto no_type_specific;
440 }
441 opaque_data += 4;
442 opaque_data_len -= 4;
443
444 if (opaque_data_len < 2) {
445 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 2",
446 opaque_data_len);
447 goto strange_opaque_data;
448 }
449 stream->num_rules = GST_READ_UINT16_BE (opaque_data);
450 opaque_data += 2;
451 opaque_data_len -= 2;
452
453 if (sel >= stream->num_rules) {
454 GST_DEBUG_OBJECT (ctx, "sel %d >= num_rules %d", sel, stream->num_rules);
455 goto strange_opaque_data;
456 }
457
458 if (opaque_data_len < 2 * sel) {
459 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT
460 " < 2 * sel (%d)", opaque_data_len, 2 * sel);
461 goto strange_opaque_data;
462 }
463 opaque_data += 2 * sel;
464 opaque_data_len -= 2 * sel;
465
466 if (opaque_data_len < 2) {
467 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 2",
468 opaque_data_len);
469 goto strange_opaque_data;
470 }
471 stream->codec = GST_READ_UINT16_BE (opaque_data);
472 opaque_data += 2;
473 opaque_data_len -= 2;
474
475 if (opaque_data_len < 2 * (stream->num_rules - sel - 1)) {
476 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT
477 " < %d", opaque_data_len, 2 * (stream->num_rules - sel - 1));
478 goto strange_opaque_data;
479 }
480 opaque_data += 2 * (stream->num_rules - sel - 1);
481 opaque_data_len -= 2 * (stream->num_rules - sel - 1);
482
483 if (opaque_data_len < 2) {
484 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 2",
485 opaque_data_len);
486 goto strange_opaque_data;
487 }
488 stream->num_rules = GST_READ_UINT16_BE (opaque_data);
489 opaque_data += 2;
490 opaque_data_len -= 2;
491
492 if (stream->codec > stream->num_rules) {
493 GST_DEBUG_OBJECT (ctx, "codec %d > num_rules %d", stream->codec,
494 stream->num_rules);
495 goto strange_opaque_data;
496 }
497
498 for (j = 0; j < stream->codec; j++) {
499 if (opaque_data_len < 4) {
500 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 4",
501 opaque_data_len);
502 goto strange_opaque_data;
503 }
504 len = GST_READ_UINT32_BE (opaque_data);
505 opaque_data += 4;
506 opaque_data_len -= 4;
507
508 if (opaque_data_len < len) {
509 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < len %d",
510 opaque_data_len, len);
511 goto strange_opaque_data;
512 }
513 opaque_data += len;
514 opaque_data_len -= len;
515 }
516
517 if (opaque_data_len < 4) {
518 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < 4",
519 opaque_data_len);
520 goto strange_opaque_data;
521 }
522 stream->type_specific_data_len = GST_READ_UINT32_BE (opaque_data);
523 opaque_data += 4;
524 opaque_data_len -= 4;
525
526 if (opaque_data_len < stream->type_specific_data_len) {
527 GST_DEBUG_OBJECT (ctx, "opaque_data_len %" G_GSIZE_FORMAT " < %d",
528 opaque_data_len, stream->type_specific_data_len);
529 goto strange_opaque_data;
530 }
531 stream->type_specific_data =
532 g_memdup (opaque_data, stream->type_specific_data_len);
533
534 no_type_specific:
535 size =
536 46 + stream->stream_name_len + stream->mime_type_len +
537 stream->type_specific_data_len;
538 ENSURE_SIZE (offset + size);
539 datap = data + offset;
540
541 memcpy (datap, "MDPR", 4);
542 GST_WRITE_UINT32_BE (datap + 4, size);
543 GST_WRITE_UINT16_BE (datap + 8, 0);
544 GST_WRITE_UINT16_BE (datap + 10, i);
545 GST_WRITE_UINT32_BE (datap + 12, stream->max_bit_rate);
546 GST_WRITE_UINT32_BE (datap + 16, stream->avg_bit_rate);
547 GST_WRITE_UINT32_BE (datap + 20, stream->max_packet_size);
548 GST_WRITE_UINT32_BE (datap + 24, stream->avg_packet_size);
549 GST_WRITE_UINT32_BE (datap + 28, stream->start_time);
550 GST_WRITE_UINT32_BE (datap + 32, stream->preroll);
551 GST_WRITE_UINT32_BE (datap + 36, stream->duration);
552 datap += 40;
553 WRITE_STRING1 (datap, stream->stream_name, stream->stream_name_len);
554 WRITE_STRING1 (datap, stream->mime_type, stream->mime_type_len);
555 GST_WRITE_UINT32_BE (datap, stream->type_specific_data_len);
556 if (stream->type_specific_data_len)
557 memcpy (datap + 4, stream->type_specific_data,
558 stream->type_specific_data_len);
559 offset += size;
560 }
561
562 /* destroy the rulebook hashtable now */
563 g_hash_table_destroy (vars);
564
565 /* strip final , if we added some stream rules */
566 if (rules->len > 0) {
567 rules = g_string_truncate (rules, rules->len - 1);
568 }
569
570 /* and store rules in the context */
571 ctx->rules = g_string_free (rules, FALSE);
572
573 /* DATA */
574 size = 18;
575 ENSURE_SIZE (offset + size);
576 datap = data + offset;
577
578 memcpy (datap, "DATA", 4);
579 GST_WRITE_UINT32_BE (datap + 4, size);
580 GST_WRITE_UINT16_BE (datap + 8, 0);
581 GST_WRITE_UINT32_BE (datap + 10, 0); /* number of packets */
582 GST_WRITE_UINT32_BE (datap + 14, 0); /* next data header */
583 offset += size;
584
585 buf = gst_buffer_new_wrapped (data, offset);
586
587 /* Set on caps */
588 GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER);
589 gst_structure_set (props, "config", GST_TYPE_BUFFER, buf, NULL);
590 gst_buffer_unref (buf);
591
592 /* Overwrite encoding and media fields */
593 gst_structure_set (props, "encoding-name", G_TYPE_STRING, "X-REAL-RDT", NULL);
594 gst_structure_set (props, "media", G_TYPE_STRING, "application", NULL);
595
596 return TRUE;
597
598 /* ERRORS */
599 strange_opaque_data:
600 {
601 g_string_free (rules, TRUE);
602 g_hash_table_destroy (vars);
603 g_free (data);
604
605 GST_ELEMENT_ERROR (ctx, RESOURCE, WRITE, ("Strange opaque data."), (NULL));
606 return FALSE;
607 }
608 }
609
610 static GstRTSPResult
rtsp_ext_real_stream_select(GstRTSPExtension * ext,GstRTSPUrl * url)611 rtsp_ext_real_stream_select (GstRTSPExtension * ext, GstRTSPUrl * url)
612 {
613 GstRTSPReal *ctx = (GstRTSPReal *) ext;
614 GstRTSPResult res;
615 GstRTSPMessage request = { 0 };
616 GstRTSPMessage response = { 0 };
617 gchar *req_url;
618
619 if (!ctx->isreal)
620 return GST_RTSP_OK;
621
622 if (!ctx->rules)
623 return GST_RTSP_OK;
624
625 req_url = gst_rtsp_url_get_request_uri (url);
626
627 /* create SET_PARAMETER */
628 if ((res = gst_rtsp_message_init_request (&request, GST_RTSP_SET_PARAMETER,
629 req_url)) < 0)
630 goto create_request_failed;
631
632 g_free (req_url);
633
634 gst_rtsp_message_add_header (&request, GST_RTSP_HDR_SUBSCRIBE, ctx->rules);
635
636 /* send SET_PARAMETER */
637 if ((res = gst_rtsp_extension_send (ext, &request, &response)) < 0)
638 goto send_error;
639
640 gst_rtsp_message_unset (&request);
641 gst_rtsp_message_unset (&response);
642
643 return GST_RTSP_OK;
644
645 /* ERRORS */
646 create_request_failed:
647 {
648 GST_ELEMENT_ERROR (ctx, LIBRARY, INIT,
649 ("Could not create request."), (NULL));
650 g_free (req_url);
651 goto reset;
652 }
653 send_error:
654 {
655 GST_ELEMENT_ERROR (ctx, RESOURCE, WRITE,
656 ("Could not send message."), (NULL));
657 goto reset;
658 }
659 reset:
660 {
661 gst_rtsp_message_unset (&request);
662 gst_rtsp_message_unset (&response);
663 return res;
664 }
665 }
666
667 static void gst_rtsp_real_extension_init (gpointer g_iface,
668 gpointer iface_data);
669 static void gst_rtsp_real_finalize (GObject * obj);
670
671 #define gst_rtsp_real_parent_class parent_class
672 G_DEFINE_TYPE_WITH_CODE (GstRTSPReal, gst_rtsp_real, GST_TYPE_ELEMENT,
673 G_IMPLEMENT_INTERFACE (GST_TYPE_RTSP_EXTENSION,
674 gst_rtsp_real_extension_init));
675
676 static void
gst_rtsp_real_class_init(GstRTSPRealClass * g_class)677 gst_rtsp_real_class_init (GstRTSPRealClass * g_class)
678 {
679 GObjectClass *gobject_class = (GObjectClass *) g_class;
680 GstElementClass *gstelement_class = (GstElementClass *) g_class;
681
682 gobject_class->finalize = gst_rtsp_real_finalize;
683
684 gst_element_class_set_static_metadata (gstelement_class,
685 "RealMedia RTSP Extension", "Network/Extension/Protocol",
686 "Extends RTSP so that it can handle RealMedia setup",
687 "Wim Taymans <wim.taymans@gmail.com>");
688
689 GST_DEBUG_CATEGORY_INIT (rtspreal_debug, "rtspreal", 0,
690 "RealMedia RTSP extension");
691 }
692
693 static void
gst_rtsp_real_init(GstRTSPReal * rtspreal)694 gst_rtsp_real_init (GstRTSPReal * rtspreal)
695 {
696 rtspreal->isreal = FALSE;
697 }
698
699 static void
gst_rtsp_stream_free(GstRTSPRealStream * stream)700 gst_rtsp_stream_free (GstRTSPRealStream * stream)
701 {
702 g_free (stream->stream_name);
703 g_free (stream->mime_type);
704 gst_asm_rule_book_free (stream->rulebook);
705 g_free (stream->type_specific_data);
706
707 g_free (stream);
708 }
709
710 static void
gst_rtsp_real_finalize(GObject * obj)711 gst_rtsp_real_finalize (GObject * obj)
712 {
713 GstRTSPReal *r = (GstRTSPReal *) obj;
714
715 g_list_foreach (r->streams, (GFunc) gst_rtsp_stream_free, NULL);
716 g_list_free (r->streams);
717 g_free (r->rules);
718
719 G_OBJECT_CLASS (parent_class)->finalize (obj);
720 }
721
722 static void
gst_rtsp_real_extension_init(gpointer g_iface,gpointer iface_data)723 gst_rtsp_real_extension_init (gpointer g_iface, gpointer iface_data)
724 {
725 GstRTSPExtensionInterface *iface = (GstRTSPExtensionInterface *) g_iface;
726
727 iface->before_send = rtsp_ext_real_before_send;
728 iface->after_send = rtsp_ext_real_after_send;
729 iface->parse_sdp = rtsp_ext_real_parse_sdp;
730 iface->stream_select = rtsp_ext_real_stream_select;
731 iface->get_transports = rtsp_ext_real_get_transports;
732 }
733
734 gboolean
gst_rtsp_real_plugin_init(GstPlugin * plugin)735 gst_rtsp_real_plugin_init (GstPlugin * plugin)
736 {
737 return gst_element_register (plugin, "rtspreal",
738 GST_RANK_MARGINAL, GST_TYPE_RTSP_REAL);
739 }
740