Mercurial > mplayer.hg
comparison stream/realrtsp/real.c @ 19271:64d82a45a05d
introduce new 'stream' directory for all stream layer related components and split them from libmpdemux
author | ben |
---|---|
date | Mon, 31 Jul 2006 17:39:17 +0000 |
parents | libmpdemux/realrtsp/real.c@240318c2460f |
children | b8f069b793c2 |
comparison
equal
deleted
inserted
replaced
19270:7d39b911f0bd | 19271:64d82a45a05d |
---|---|
1 /* | |
2 * This file was ported to MPlayer from xine CVS real.c,v 1.8 2003/03/30 17:11:50 | |
3 */ | |
4 | |
5 /* | |
6 * Copyright (C) 2002 the xine project | |
7 * | |
8 * This file is part of xine, a free video player. | |
9 * | |
10 * xine is free software; you can redistribute it and/or modify | |
11 * it under the terms of the GNU General Public License as published by | |
12 * the Free Software Foundation; either version 2 of the License, or | |
13 * (at your option) any later version. | |
14 * | |
15 * xine is distributed in the hope that it will be useful, | |
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 * GNU General Public License for more details. | |
19 * | |
20 * You should have received a copy of the GNU General Public License | |
21 * along with this program; if not, write to the Free Software | |
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | |
23 * | |
24 * | |
25 * special functions for real streams. | |
26 * adopted from joschkas real tools. | |
27 * | |
28 */ | |
29 | |
30 #include <stdio.h> | |
31 #include <string.h> | |
32 | |
33 #include "../config.h" | |
34 #include "../bswap.h" | |
35 #include "real.h" | |
36 #include "asmrp.h" | |
37 #include "sdpplin.h" | |
38 #include "xbuffer.h" | |
39 #if USE_LIBAVUTIL_SO | |
40 #include "ffmpeg/md5.h" | |
41 #else | |
42 #include "libavutil/md5.h" | |
43 #endif | |
44 | |
45 /* | |
46 #define LOG | |
47 */ | |
48 | |
49 static const unsigned char xor_table[] = { | |
50 0x05, 0x18, 0x74, 0xd0, 0x0d, 0x09, 0x02, 0x53, | |
51 0xc0, 0x01, 0x05, 0x05, 0x67, 0x03, 0x19, 0x70, | |
52 0x08, 0x27, 0x66, 0x10, 0x10, 0x72, 0x08, 0x09, | |
53 0x63, 0x11, 0x03, 0x71, 0x08, 0x08, 0x70, 0x02, | |
54 0x10, 0x57, 0x05, 0x18, 0x54, 0x00, 0x00, 0x00 }; | |
55 | |
56 | |
57 #define BE_32C(x,y) (*((uint32_t*)(x))=be2me_32(y)) | |
58 | |
59 #define BE_16(x) be2me_16(*(uint16_t*)(x)) | |
60 | |
61 #define BE_32(x) be2me_32(*(uint32_t*)(x)) | |
62 | |
63 #ifndef MAX | |
64 #define MAX(x,y) ((x>y) ? x : y) | |
65 #endif | |
66 | |
67 #define BUF_SIZE 4096 | |
68 | |
69 #ifdef LOG | |
70 static void hexdump (const char *buf, int length) { | |
71 | |
72 int i; | |
73 | |
74 printf (" hexdump> "); | |
75 for (i = 0; i < length; i++) { | |
76 unsigned char c = buf[i]; | |
77 | |
78 printf ("%02x", c); | |
79 | |
80 if ((i % 16) == 15) | |
81 printf ("\n "); | |
82 | |
83 if ((i % 2) == 1) | |
84 printf (" "); | |
85 | |
86 } | |
87 printf ("\n"); | |
88 } | |
89 #endif | |
90 | |
91 | |
92 static void calc_response_string (char *result, char *challenge) { | |
93 | |
94 char zres[16]; | |
95 int i; | |
96 | |
97 av_md5_sum(zres, challenge, 64); | |
98 | |
99 /* convert zres to ascii string */ | |
100 for (i=0; i<16; i++ ) { | |
101 char a, b; | |
102 | |
103 a = (zres[i] >> 4) & 15; | |
104 b = zres[i] & 15; | |
105 | |
106 result[i*2] = ((a<10) ? (a+48) : (a+87)) & 255; | |
107 result[i*2+1] = ((b<10) ? (b+48) : (b+87)) & 255; | |
108 } | |
109 } | |
110 | |
111 static void real_calc_response_and_checksum (char *response, char *chksum, char *challenge) { | |
112 | |
113 int ch_len, table_len, resp_len; | |
114 int i; | |
115 char *ptr; | |
116 char buf[128]; | |
117 | |
118 /* initialize return values */ | |
119 memset(response, 0, 64); | |
120 memset(chksum, 0, 34); | |
121 | |
122 /* initialize buffer */ | |
123 memset(buf, 0, 128); | |
124 ptr=buf; | |
125 BE_32C(ptr, 0xa1e9149d); | |
126 ptr+=4; | |
127 BE_32C(ptr, 0x0e6b3b59); | |
128 ptr+=4; | |
129 | |
130 /* some (length) checks */ | |
131 if (challenge != NULL) | |
132 { | |
133 ch_len = strlen (challenge); | |
134 | |
135 if (ch_len == 40) /* what a hack... */ | |
136 { | |
137 challenge[32]=0; | |
138 ch_len=32; | |
139 } | |
140 if ( ch_len > 56 ) ch_len=56; | |
141 | |
142 /* copy challenge to buf */ | |
143 memcpy(ptr, challenge, ch_len); | |
144 } | |
145 | |
146 table_len = strlen(xor_table); | |
147 | |
148 if (table_len > 56) table_len=56; | |
149 | |
150 /* xor challenge bytewise with xor_table */ | |
151 for (i=0; i<table_len; i++) | |
152 ptr[i] = ptr[i] ^ xor_table[i]; | |
153 | |
154 calc_response_string (response, buf); | |
155 | |
156 /* add tail */ | |
157 resp_len = strlen (response); | |
158 strcpy (&response[resp_len], "01d0a8e3"); | |
159 | |
160 /* calculate checksum */ | |
161 for (i=0; i<resp_len/4; i++) | |
162 chksum[i] = response[i*4]; | |
163 } | |
164 | |
165 | |
166 /* | |
167 * takes a MLTI-Chunk and a rule number got from match_asm_rule, | |
168 * returns a pointer to selected data and number of bytes in that. | |
169 */ | |
170 | |
171 static int select_mlti_data(const char *mlti_chunk, int mlti_size, int selection, char **out) { | |
172 | |
173 int numrules, codec, size; | |
174 int i; | |
175 | |
176 /* MLTI chunk should begin with MLTI */ | |
177 | |
178 if ((mlti_chunk[0] != 'M') | |
179 ||(mlti_chunk[1] != 'L') | |
180 ||(mlti_chunk[2] != 'T') | |
181 ||(mlti_chunk[3] != 'I')) | |
182 { | |
183 #ifdef LOG | |
184 printf("libreal: MLTI tag not detected, copying data\n"); | |
185 #endif | |
186 *out = xbuffer_copyin(*out, 0, mlti_chunk, mlti_size); | |
187 return mlti_size; | |
188 } | |
189 | |
190 mlti_chunk+=4; | |
191 | |
192 /* next 16 bits are the number of rules */ | |
193 numrules=BE_16(mlti_chunk); | |
194 if (selection >= numrules) return 0; | |
195 | |
196 /* now <numrules> indices of codecs follows */ | |
197 /* we skip to selection */ | |
198 mlti_chunk+=(selection+1)*2; | |
199 | |
200 /* get our index */ | |
201 codec=BE_16(mlti_chunk); | |
202 | |
203 /* skip to number of codecs */ | |
204 mlti_chunk+=(numrules-selection)*2; | |
205 | |
206 /* get number of codecs */ | |
207 numrules=BE_16(mlti_chunk); | |
208 | |
209 if (codec >= numrules) { | |
210 printf("codec index >= number of codecs. %i %i\n", codec, numrules); | |
211 return 0; | |
212 } | |
213 | |
214 mlti_chunk+=2; | |
215 | |
216 /* now seek to selected codec */ | |
217 for (i=0; i<codec; i++) { | |
218 size=BE_32(mlti_chunk); | |
219 mlti_chunk+=size+4; | |
220 } | |
221 | |
222 size=BE_32(mlti_chunk); | |
223 | |
224 #ifdef LOG | |
225 hexdump(mlti_chunk+4, size); | |
226 #endif | |
227 *out = xbuffer_copyin(*out, 0, mlti_chunk+4, size); | |
228 return size; | |
229 } | |
230 | |
231 /* | |
232 * looking at stream description. | |
233 */ | |
234 | |
235 static rmff_header_t *real_parse_sdp(char *data, char **stream_rules, uint32_t bandwidth) { | |
236 | |
237 sdpplin_t *desc; | |
238 rmff_header_t *header; | |
239 char *buf; | |
240 int len, i; | |
241 int max_bit_rate=0; | |
242 int avg_bit_rate=0; | |
243 int max_packet_size=0; | |
244 int avg_packet_size=0; | |
245 int duration=0; | |
246 | |
247 | |
248 if (!data) return NULL; | |
249 | |
250 desc=sdpplin_parse(data); | |
251 | |
252 if (!desc) return NULL; | |
253 | |
254 buf = xbuffer_init(2048); | |
255 header=calloc(1,sizeof(rmff_header_t)); | |
256 | |
257 header->fileheader=rmff_new_fileheader(4+desc->stream_count); | |
258 header->cont=rmff_new_cont( | |
259 desc->title, | |
260 desc->author, | |
261 desc->copyright, | |
262 desc->abstract); | |
263 header->data=rmff_new_dataheader(0,0); | |
264 header->streams=calloc(1,sizeof(rmff_mdpr_t*)*(desc->stream_count+1)); | |
265 #ifdef LOG | |
266 printf("number of streams: %u\n", desc->stream_count); | |
267 #endif | |
268 | |
269 for (i=0; i<desc->stream_count; i++) { | |
270 | |
271 int j=0; | |
272 int n; | |
273 char b[64]; | |
274 int rulematches[16]; | |
275 | |
276 #ifdef LOG | |
277 printf("calling asmrp_match with:\n%s\n%u\n", desc->stream[i]->asm_rule_book, bandwidth); | |
278 #endif | |
279 n=asmrp_match(desc->stream[i]->asm_rule_book, bandwidth, rulematches); | |
280 for (j=0; j<n; j++) { | |
281 #ifdef LOG | |
282 printf("asmrp rule match: %u for stream %u\n", rulematches[j], desc->stream[i]->stream_id); | |
283 #endif | |
284 sprintf(b,"stream=%u;rule=%u,", desc->stream[i]->stream_id, rulematches[j]); | |
285 *stream_rules = xbuffer_strcat(*stream_rules, b); | |
286 } | |
287 | |
288 if (!desc->stream[i]->mlti_data) { | |
289 len = 0; | |
290 buf = NULL; | |
291 } else | |
292 len=select_mlti_data(desc->stream[i]->mlti_data, desc->stream[i]->mlti_data_size, rulematches[0], &buf); | |
293 | |
294 header->streams[i]=rmff_new_mdpr( | |
295 desc->stream[i]->stream_id, | |
296 desc->stream[i]->max_bit_rate, | |
297 desc->stream[i]->avg_bit_rate, | |
298 desc->stream[i]->max_packet_size, | |
299 desc->stream[i]->avg_packet_size, | |
300 desc->stream[i]->start_time, | |
301 desc->stream[i]->preroll, | |
302 desc->stream[i]->duration, | |
303 desc->stream[i]->stream_name, | |
304 desc->stream[i]->mime_type, | |
305 len, | |
306 buf); | |
307 | |
308 duration=MAX(duration,desc->stream[i]->duration); | |
309 max_bit_rate+=desc->stream[i]->max_bit_rate; | |
310 avg_bit_rate+=desc->stream[i]->avg_bit_rate; | |
311 max_packet_size=MAX(max_packet_size, desc->stream[i]->max_packet_size); | |
312 if (avg_packet_size) | |
313 avg_packet_size=(avg_packet_size + desc->stream[i]->avg_packet_size) / 2; | |
314 else | |
315 avg_packet_size=desc->stream[i]->avg_packet_size; | |
316 } | |
317 | |
318 if (*stream_rules && strlen(*stream_rules) && (*stream_rules)[strlen(*stream_rules)-1] == ',') | |
319 (*stream_rules)[strlen(*stream_rules)-1]=0; /* delete last ',' in stream_rules */ | |
320 | |
321 header->prop=rmff_new_prop( | |
322 max_bit_rate, | |
323 avg_bit_rate, | |
324 max_packet_size, | |
325 avg_packet_size, | |
326 0, | |
327 duration, | |
328 0, | |
329 0, | |
330 0, | |
331 desc->stream_count, | |
332 desc->flags); | |
333 | |
334 rmff_fix_header(header); | |
335 buf = xbuffer_free(buf); | |
336 | |
337 return header; | |
338 } | |
339 | |
340 int real_get_rdt_chunk(rtsp_t *rtsp_session, char **buffer) { | |
341 | |
342 int n=1; | |
343 uint8_t header[8]; | |
344 rmff_pheader_t ph; | |
345 int size; | |
346 int flags1, flags2; | |
347 int unknown1; | |
348 uint32_t ts; | |
349 static uint32_t prev_ts = -1; | |
350 static int prev_stream_number = -1; | |
351 | |
352 n=rtsp_read_data(rtsp_session, header, 8); | |
353 if (n<8) return 0; | |
354 if (header[0] != 0x24) | |
355 { | |
356 printf("rdt chunk not recognized: got 0x%02x\n", header[0]); | |
357 return 0; | |
358 } | |
359 size=(header[1]<<16)+(header[2]<<8)+(header[3]); | |
360 flags1=header[4]; | |
361 if ((flags1!=0x40)&&(flags1!=0x42)) | |
362 { | |
363 #ifdef LOG | |
364 printf("got flags1: 0x%02x\n",flags1); | |
365 #endif | |
366 if(header[6] == 0x06) { | |
367 printf("Stream EOF detected\n"); | |
368 return -1; | |
369 } | |
370 header[0]=header[5]; | |
371 header[1]=header[6]; | |
372 header[2]=header[7]; | |
373 n=rtsp_read_data(rtsp_session, header+3, 5); | |
374 if (n<5) return 0; | |
375 #ifdef LOG | |
376 printf("ignoring bytes:\n"); | |
377 hexdump(header, 8); | |
378 #endif | |
379 n=rtsp_read_data(rtsp_session, header+4, 4); | |
380 if (n<4) return 0; | |
381 flags1=header[4]; | |
382 size-=9; | |
383 } | |
384 flags2=header[7]; | |
385 // header[5..6] == frame number in stream | |
386 unknown1=(header[5]<<16)+(header[6]<<8)+(header[7]); | |
387 n=rtsp_read_data(rtsp_session, header, 6); | |
388 if (n<6) return 0; | |
389 ts=BE_32(header); | |
390 | |
391 #ifdef LOG | |
392 printf("ts: %u, size: %u, flags: 0x%02x, unknown values: 0x%06x 0x%02x 0x%02x\n", | |
393 ts, size, flags1, unknown1, header[4], header[5]); | |
394 #endif | |
395 size+=2; | |
396 | |
397 ph.object_version=0; | |
398 ph.length=size; | |
399 ph.stream_number=(flags1>>1)&1; | |
400 ph.timestamp=ts; | |
401 ph.reserved=0; | |
402 if ((flags2&1) == 0 && (prev_ts != ts || prev_stream_number != ph.stream_number)) | |
403 { | |
404 prev_ts = ts; | |
405 prev_stream_number = ph.stream_number; | |
406 ph.flags=2; | |
407 } | |
408 else | |
409 ph.flags=0; | |
410 *buffer = xbuffer_ensure_size(*buffer, 12+size); | |
411 rmff_dump_pheader(&ph, *buffer); | |
412 size-=12; | |
413 n=rtsp_read_data(rtsp_session, (*buffer)+12, size); | |
414 | |
415 return (n <= 0) ? 0 : n+12; | |
416 } | |
417 | |
418 static int convert_timestamp(char *str, int *sec, int *msec) { | |
419 int hh, mm, ss, ms = 0; | |
420 if (sscanf(str, "%d:%d:%d.%d", &hh, &mm, &ss, &ms) < 3) { | |
421 hh = 0; | |
422 if (sscanf(str, "%d:%d.%d", &mm, &ss, &ms) < 2) { | |
423 mm = 0; | |
424 if (sscanf(str, "%d.%d", &ss, &ms) < 1) { | |
425 ss = 0; | |
426 ms = 0; | |
427 } | |
428 } | |
429 } | |
430 if (sec) | |
431 *sec = hh * 3600 + mm * 60 + ss; | |
432 if (msec) | |
433 *msec = ms; | |
434 return 1; | |
435 } | |
436 | |
437 //! maximum size of the rtsp description, must be < INT_MAX | |
438 #define MAX_DESC_BUF (20 * 1024 * 1024) | |
439 rmff_header_t *real_setup_and_get_header(rtsp_t *rtsp_session, uint32_t bandwidth) { | |
440 | |
441 char *description=NULL; | |
442 char *session_id=NULL; | |
443 rmff_header_t *h; | |
444 char *challenge1; | |
445 char challenge2[64]; | |
446 char checksum[34]; | |
447 char *subscribe; | |
448 char *buf = xbuffer_init(256); | |
449 char *mrl=rtsp_get_mrl(rtsp_session); | |
450 unsigned int size; | |
451 int status; | |
452 uint32_t maxbandwidth = bandwidth; | |
453 | |
454 /* get challenge */ | |
455 challenge1=strdup(rtsp_search_answers(rtsp_session,"RealChallenge1")); | |
456 #ifdef LOG | |
457 printf("real: Challenge1: %s\n", challenge1); | |
458 #endif | |
459 | |
460 /* set a reasonable default to get the best stream, unless bandwidth given */ | |
461 if (!bandwidth) | |
462 bandwidth = 10485800; | |
463 | |
464 /* request stream description */ | |
465 rtsp_schedule_field(rtsp_session, "Accept: application/sdp"); | |
466 sprintf(buf, "Bandwidth: %u", bandwidth); | |
467 rtsp_schedule_field(rtsp_session, buf); | |
468 rtsp_schedule_field(rtsp_session, "GUID: 00000000-0000-0000-0000-000000000000"); | |
469 rtsp_schedule_field(rtsp_session, "RegionData: 0"); | |
470 rtsp_schedule_field(rtsp_session, "ClientID: Linux_2.4_6.0.9.1235_play32_RN01_EN_586"); | |
471 rtsp_schedule_field(rtsp_session, "SupportsMaximumASMBandwidth: 1"); | |
472 rtsp_schedule_field(rtsp_session, "Language: en-US"); | |
473 rtsp_schedule_field(rtsp_session, "Require: com.real.retain-entity-for-setup"); | |
474 status=rtsp_request_describe(rtsp_session,NULL); | |
475 | |
476 if ( status<200 || status>299 ) | |
477 { | |
478 char *alert=rtsp_search_answers(rtsp_session,"Alert"); | |
479 if (alert) { | |
480 printf("real: got message from server:\n%s\n", alert); | |
481 } | |
482 rtsp_send_ok(rtsp_session); | |
483 buf = xbuffer_free(buf); | |
484 return NULL; | |
485 } | |
486 | |
487 /* receive description */ | |
488 size=0; | |
489 if (!rtsp_search_answers(rtsp_session,"Content-length")) | |
490 printf("real: got no Content-length!\n"); | |
491 else | |
492 size=atoi(rtsp_search_answers(rtsp_session,"Content-length")); | |
493 | |
494 // as size is unsigned this also catches the case (size < 0) | |
495 if (size > MAX_DESC_BUF) { | |
496 printf("real: Content-length for description too big (> %uMB)!\n", | |
497 MAX_DESC_BUF/(1024*1024) ); | |
498 xbuffer_free(buf); | |
499 return NULL; | |
500 } | |
501 | |
502 if (!rtsp_search_answers(rtsp_session,"ETag")) | |
503 printf("real: got no ETag!\n"); | |
504 else | |
505 session_id=strdup(rtsp_search_answers(rtsp_session,"ETag")); | |
506 | |
507 #ifdef LOG | |
508 printf("real: Stream description size: %u\n", size); | |
509 #endif | |
510 | |
511 description=malloc(size+1); | |
512 | |
513 if( rtsp_read_data(rtsp_session, description, size) <= 0) { | |
514 buf = xbuffer_free(buf); | |
515 return NULL; | |
516 } | |
517 description[size]=0; | |
518 | |
519 /* parse sdp (sdpplin) and create a header and a subscribe string */ | |
520 subscribe = xbuffer_init(256); | |
521 strcpy(subscribe, "Subscribe: "); | |
522 h=real_parse_sdp(description, &subscribe, bandwidth); | |
523 if (!h) { | |
524 subscribe = xbuffer_free(subscribe); | |
525 buf = xbuffer_free(buf); | |
526 return NULL; | |
527 } | |
528 rmff_fix_header(h); | |
529 | |
530 #ifdef LOG | |
531 printf("Title: %s\nCopyright: %s\nAuthor: %s\nStreams: %i\n", | |
532 h->cont->title, h->cont->copyright, h->cont->author, h->prop->num_streams); | |
533 #endif | |
534 | |
535 /* setup our streams */ | |
536 real_calc_response_and_checksum (challenge2, checksum, challenge1); | |
537 buf = xbuffer_ensure_size(buf, strlen(challenge2) + strlen(checksum) + 32); | |
538 sprintf(buf, "RealChallenge2: %s, sd=%s", challenge2, checksum); | |
539 rtsp_schedule_field(rtsp_session, buf); | |
540 buf = xbuffer_ensure_size(buf, strlen(session_id) + 32); | |
541 sprintf(buf, "If-Match: %s", session_id); | |
542 rtsp_schedule_field(rtsp_session, buf); | |
543 rtsp_schedule_field(rtsp_session, "Transport: x-pn-tng/tcp;mode=play,rtp/avp/tcp;unicast;mode=play"); | |
544 buf = xbuffer_ensure_size(buf, strlen(mrl) + 32); | |
545 sprintf(buf, "%s/streamid=0", mrl); | |
546 rtsp_request_setup(rtsp_session,buf,NULL); | |
547 | |
548 if (h->prop->num_streams > 1) { | |
549 rtsp_schedule_field(rtsp_session, "Transport: x-pn-tng/tcp;mode=play,rtp/avp/tcp;unicast;mode=play"); | |
550 buf = xbuffer_ensure_size(buf, strlen(session_id) + 32); | |
551 sprintf(buf, "If-Match: %s", session_id); | |
552 rtsp_schedule_field(rtsp_session, buf); | |
553 | |
554 buf = xbuffer_ensure_size(buf, strlen(mrl) + 32); | |
555 sprintf(buf, "%s/streamid=1", mrl); | |
556 rtsp_request_setup(rtsp_session,buf,NULL); | |
557 } | |
558 /* set stream parameter (bandwidth) with our subscribe string */ | |
559 rtsp_schedule_field(rtsp_session, subscribe); | |
560 rtsp_request_setparameter(rtsp_session,NULL); | |
561 | |
562 /* set delivery bandwidth */ | |
563 if (maxbandwidth) { | |
564 sprintf(buf, "SetDeliveryBandwidth: Bandwidth=%u;BackOff=0", maxbandwidth); | |
565 rtsp_schedule_field(rtsp_session, buf); | |
566 rtsp_request_setparameter(rtsp_session,NULL); | |
567 } | |
568 | |
569 { | |
570 int s_ss = 0, s_ms = 0, e_ss = 0, e_ms = 0; | |
571 char *str; | |
572 if ((str = rtsp_get_param(rtsp_session, "start"))) { | |
573 convert_timestamp(str, &s_ss, &s_ms); | |
574 free(str); | |
575 } | |
576 if ((str = rtsp_get_param(rtsp_session, "end"))) { | |
577 convert_timestamp(str, &e_ss, &e_ms); | |
578 free(str); | |
579 } | |
580 str = buf + sprintf(buf, s_ms ? "%s%d.%d-" : "%s%d-", "Range: npt=", s_ss, s_ms); | |
581 if (e_ss || e_ms) | |
582 sprintf(str, e_ms ? "%d.%d" : "%d", e_ss, e_ms); | |
583 } | |
584 rtsp_schedule_field(rtsp_session, buf); | |
585 /* and finally send a play request */ | |
586 rtsp_request_play(rtsp_session,NULL); | |
587 | |
588 subscribe = xbuffer_free(subscribe); | |
589 buf = xbuffer_free(buf); | |
590 return h; | |
591 } | |
592 | |
593 struct real_rtsp_session_t * | |
594 init_real_rtsp_session (void) | |
595 { | |
596 struct real_rtsp_session_t *real_rtsp_session = NULL; | |
597 | |
598 real_rtsp_session = malloc (sizeof (struct real_rtsp_session_t)); | |
599 real_rtsp_session->recv = xbuffer_init (BUF_SIZE); | |
600 | |
601 return real_rtsp_session; | |
602 } | |
603 | |
604 void | |
605 free_real_rtsp_session (struct real_rtsp_session_t* real_session) | |
606 { | |
607 if (!real_session) | |
608 return; | |
609 | |
610 xbuffer_free (real_session->recv); | |
611 free (real_session); | |
612 } |