FFmpeg
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
Examples
File List
Globals
•
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
libavformat
rtsp.h
Go to the documentation of this file.
1
/*
2
* RTSP definitions
3
* Copyright (c) 2002 Fabrice Bellard
4
*
5
* This file is part of FFmpeg.
6
*
7
* FFmpeg is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU Lesser General Public
9
* License as published by the Free Software Foundation; either
10
* version 2.1 of the License, or (at your option) any later version.
11
*
12
* FFmpeg is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* Lesser General Public License for more details.
16
*
17
* You should have received a copy of the GNU Lesser General Public
18
* License along with FFmpeg; if not, write to the Free Software
19
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
*/
21
#ifndef AVFORMAT_RTSP_H
22
#define AVFORMAT_RTSP_H
23
24
#include <stdint.h>
25
#include "
avformat.h
"
26
#include "
rtspcodes.h
"
27
#include "
rtpdec.h
"
28
#include "
network.h
"
29
#include "
httpauth.h
"
30
31
#include "
libavutil/log.h
"
32
#include "
libavutil/opt.h
"
33
34
/**
35
* Network layer over which RTP/etc packet data will be transported.
36
*/
37
enum
RTSPLowerTransport
{
38
RTSP_LOWER_TRANSPORT_UDP
= 0,
/**< UDP/unicast */
39
RTSP_LOWER_TRANSPORT_TCP
= 1,
/**< TCP; interleaved in RTSP */
40
RTSP_LOWER_TRANSPORT_UDP_MULTICAST
= 2,
/**< UDP/multicast */
41
RTSP_LOWER_TRANSPORT_NB
,
42
RTSP_LOWER_TRANSPORT_HTTP
= 8,
/**< HTTP tunneled - not a proper
43
transport mode as such,
44
only for use via AVOptions */
45
RTSP_LOWER_TRANSPORT_CUSTOM
= 16,
/**< Custom IO - not a public
46
option for lower_transport_mask,
47
but set in the SDP demuxer based
48
on a flag. */
49
};
50
51
/**
52
* Packet profile of the data that we will be receiving. Real servers
53
* commonly send RDT (although they can sometimes send RTP as well),
54
* whereas most others will send RTP.
55
*/
56
enum
RTSPTransport
{
57
RTSP_TRANSPORT_RTP
,
/**< Standards-compliant RTP */
58
RTSP_TRANSPORT_RDT
,
/**< Realmedia Data Transport */
59
RTSP_TRANSPORT_RAW
,
/**< Raw data (over UDP) */
60
RTSP_TRANSPORT_NB
61
};
62
63
/**
64
* Transport mode for the RTSP data. This may be plain, or
65
* tunneled, which is done over HTTP.
66
*/
67
enum
RTSPControlTransport
{
68
RTSP_MODE_PLAIN
,
/**< Normal RTSP */
69
RTSP_MODE_TUNNEL
/**< RTSP over HTTP (tunneling) */
70
};
71
72
#define RTSP_DEFAULT_PORT 554
73
#define RTSPS_DEFAULT_PORT 322
74
#define RTSP_MAX_TRANSPORTS 8
75
#define RTSP_TCP_MAX_PACKET_SIZE 1472
76
#define RTSP_DEFAULT_NB_AUDIO_CHANNELS 1
77
#define RTSP_DEFAULT_AUDIO_SAMPLERATE 44100
78
#define RTSP_RTP_PORT_MIN 5000
79
#define RTSP_RTP_PORT_MAX 65000
80
81
/**
82
* This describes a single item in the "Transport:" line of one stream as
83
* negotiated by the SETUP RTSP command. Multiple transports are comma-
84
* separated ("Transport: x-read-rdt/tcp;interleaved=0-1,rtp/avp/udp;
85
* client_port=1000-1001;server_port=1800-1801") and described in separate
86
* RTSPTransportFields.
87
*/
88
typedef
struct
RTSPTransportField
{
89
/** interleave ids, if TCP transport; each TCP/RTSP data packet starts
90
* with a '$', stream length and stream ID. If the stream ID is within
91
* the range of this interleaved_min-max, then the packet belongs to
92
* this stream. */
93
int
interleaved_min
,
interleaved_max
;
94
95
/** UDP multicast port range; the ports to which we should connect to
96
* receive multicast UDP data. */
97
int
port_min
,
port_max
;
98
99
/** UDP client ports; these should be the local ports of the UDP RTP
100
* (and RTCP) sockets over which we receive RTP/RTCP data. */
101
int
client_port_min
,
client_port_max
;
102
103
/** UDP unicast server port range; the ports to which we should connect
104
* to receive unicast UDP RTP/RTCP data. */
105
int
server_port_min
,
server_port_max
;
106
107
/** time-to-live value (required for multicast); the amount of HOPs that
108
* packets will be allowed to make before being discarded. */
109
int
ttl
;
110
111
/** transport set to record data */
112
int
mode_record
;
113
114
struct
sockaddr_storage
destination
;
/**< destination IP address */
115
char
source
[
INET6_ADDRSTRLEN
+ 1];
/**< source IP address */
116
117
/** data/packet transport protocol; e.g. RTP or RDT */
118
enum
RTSPTransport
transport
;
119
120
/** network layer transport protocol; e.g. TCP or UDP uni-/multicast */
121
enum
RTSPLowerTransport
lower_transport
;
122
}
RTSPTransportField
;
123
124
/**
125
* This describes the server response to each RTSP command.
126
*/
127
typedef
struct
RTSPMessageHeader
{
128
/** length of the data following this header */
129
int
content_length
;
130
131
enum
RTSPStatusCode
status_code
;
/**< response code from server */
132
133
/** number of items in the 'transports' variable below */
134
int
nb_transports
;
135
136
/** Time range of the streams that the server will stream. In
137
* AV_TIME_BASE unit, AV_NOPTS_VALUE if not used */
138
int64_t
range_start
,
range_end
;
139
140
/** describes the complete "Transport:" line of the server in response
141
* to a SETUP RTSP command by the client */
142
RTSPTransportField
transports
[
RTSP_MAX_TRANSPORTS
];
143
144
int
seq
;
/**< sequence number */
145
146
/** the "Session:" field. This value is initially set by the server and
147
* should be re-transmitted by the client in every RTSP command. */
148
char
session_id
[512];
149
150
/** the "Location:" field. This value is used to handle redirection.
151
*/
152
char
location
[4096];
153
154
/** the "RealChallenge1:" field from the server */
155
char
real_challenge
[64];
156
157
/** the "Server: field, which can be used to identify some special-case
158
* servers that are not 100% standards-compliant. We use this to identify
159
* Windows Media Server, which has a value "WMServer/v.e.r.sion", where
160
* version is a sequence of digits (e.g. 9.0.0.3372). Helix/Real servers
161
* use something like "Helix [..] Server Version v.e.r.sion (platform)
162
* (RealServer compatible)" or "RealServer Version v.e.r.sion (platform)",
163
* where platform is the output of $uname -msr | sed 's/ /-/g'. */
164
char
server
[64];
165
166
/** The "timeout" comes as part of the server response to the "SETUP"
167
* command, in the "Session: <xyz>[;timeout=<value>]" line. It is the
168
* time, in seconds, that the server will go without traffic over the
169
* RTSP/TCP connection before it closes the connection. To prevent
170
* this, sent dummy requests (e.g. OPTIONS) with intervals smaller
171
* than this value. */
172
int
timeout
;
173
174
/** The "Notice" or "X-Notice" field value. See
175
* http://tools.ietf.org/html/draft-stiemerling-rtsp-announce-00
176
* for a complete list of supported values. */
177
int
notice
;
178
179
/** The "reason" is meant to specify better the meaning of the error code
180
* returned
181
*/
182
char
reason
[256];
183
184
/**
185
* Content type header
186
*/
187
char
content_type
[64];
188
}
RTSPMessageHeader
;
189
190
/**
191
* Client state, i.e. whether we are currently receiving data (PLAYING) or
192
* setup-but-not-receiving (PAUSED). State can be changed in applications
193
* by calling av_read_play/pause().
194
*/
195
enum
RTSPClientState
{
196
RTSP_STATE_IDLE
,
/**< not initialized */
197
RTSP_STATE_STREAMING
,
/**< initialized and sending/receiving data */
198
RTSP_STATE_PAUSED
,
/**< initialized, but not receiving data */
199
RTSP_STATE_SEEKING
,
/**< initialized, requesting a seek */
200
};
201
202
/**
203
* Identify particular servers that require special handling, such as
204
* standards-incompliant "Transport:" lines in the SETUP request.
205
*/
206
enum
RTSPServerType
{
207
RTSP_SERVER_RTP
,
/**< Standards-compliant RTP-server */
208
RTSP_SERVER_REAL
,
/**< Realmedia-style server */
209
RTSP_SERVER_WMS
,
/**< Windows Media server */
210
RTSP_SERVER_NB
211
};
212
213
/**
214
* Private data for the RTSP demuxer.
215
*
216
* @todo Use AVIOContext instead of URLContext
217
*/
218
typedef
struct
RTSPState
{
219
const
AVClass
*
class
;
/**< Class for private options. */
220
URLContext
*
rtsp_hd
;
/* RTSP TCP connection handle */
221
222
/** number of items in the 'rtsp_streams' variable */
223
int
nb_rtsp_streams
;
224
225
struct
RTSPStream
**
rtsp_streams
;
/**< streams in this session */
226
227
/** indicator of whether we are currently receiving data from the
228
* server. Basically this isn't more than a simple cache of the
229
* last PLAY/PAUSE command sent to the server, to make sure we don't
230
* send 2x the same unexpectedly or commands in the wrong state. */
231
enum
RTSPClientState
state
;
232
233
/** the seek value requested when calling av_seek_frame(). This value
234
* is subsequently used as part of the "Range" parameter when emitting
235
* the RTSP PLAY command. If we are currently playing, this command is
236
* called instantly. If we are currently paused, this command is called
237
* whenever we resume playback. Either way, the value is only used once,
238
* see rtsp_read_play() and rtsp_read_seek(). */
239
int64_t
seek_timestamp
;
240
241
int
seq
;
/**< RTSP command sequence number */
242
243
/** copy of RTSPMessageHeader->session_id, i.e. the server-provided session
244
* identifier that the client should re-transmit in each RTSP command */
245
char
session_id
[512];
246
247
/** copy of RTSPMessageHeader->timeout, i.e. the time (in seconds) that
248
* the server will go without traffic on the RTSP/TCP line before it
249
* closes the connection. */
250
int
timeout
;
251
252
/** timestamp of the last RTSP command that we sent to the RTSP server.
253
* This is used to calculate when to send dummy commands to keep the
254
* connection alive, in conjunction with timeout. */
255
int64_t
last_cmd_time
;
256
257
/** the negotiated data/packet transport protocol; e.g. RTP or RDT */
258
enum
RTSPTransport
transport
;
259
260
/** the negotiated network layer transport protocol; e.g. TCP or UDP
261
* uni-/multicast */
262
enum
RTSPLowerTransport
lower_transport
;
263
264
/** brand of server that we're talking to; e.g. WMS, REAL or other.
265
* Detected based on the value of RTSPMessageHeader->server or the presence
266
* of RTSPMessageHeader->real_challenge */
267
enum
RTSPServerType
server_type
;
268
269
/** the "RealChallenge1:" field from the server */
270
char
real_challenge
[64];
271
272
/** plaintext authorization line (username:password) */
273
char
auth
[128];
274
275
/** authentication state */
276
HTTPAuthState
auth_state
;
277
278
/** The last reply of the server to a RTSP command */
279
char
last_reply
[2048];
/* XXX: allocate ? */
280
281
/** RTSPStream->transport_priv of the last stream that we read a
282
* packet from */
283
void
*
cur_transport_priv
;
284
285
/** The following are used for Real stream selection */
286
//@{
287
/** whether we need to send a "SET_PARAMETER Subscribe:" command */
288
int
need_subscription
;
289
290
/** stream setup during the last frame read. This is used to detect if
291
* we need to subscribe or unsubscribe to any new streams. */
292
enum
AVDiscard
*
real_setup_cache
;
293
294
/** current stream setup. This is a temporary buffer used to compare
295
* current setup to previous frame setup. */
296
enum
AVDiscard
*
real_setup
;
297
298
/** the last value of the "SET_PARAMETER Subscribe:" RTSP command.
299
* this is used to send the same "Unsubscribe:" if stream setup changed,
300
* before sending a new "Subscribe:" command. */
301
char
last_subscription
[1024];
302
//@}
303
304
/** The following are used for RTP/ASF streams */
305
//@{
306
/** ASF demuxer context for the embedded ASF stream from WMS servers */
307
AVFormatContext
*
asf_ctx
;
308
309
/** cache for position of the asf demuxer, since we load a new
310
* data packet in the bytecontext for each incoming RTSP packet. */
311
uint64_t
asf_pb_pos
;
312
//@}
313
314
/** some MS RTSP streams contain a URL in the SDP that we need to use
315
* for all subsequent RTSP requests, rather than the input URI; in
316
* other cases, this is a copy of AVFormatContext->filename. */
317
char
control_uri
[1024];
318
319
/** The following are used for parsing raw mpegts in udp */
320
//@{
321
struct
MpegTSContext
*
ts
;
322
int
recvbuf_pos
;
323
int
recvbuf_len
;
324
//@}
325
326
/** Additional output handle, used when input and output are done
327
* separately, eg for HTTP tunneling. */
328
URLContext
*
rtsp_hd_out
;
329
330
/** RTSP transport mode, such as plain or tunneled. */
331
enum
RTSPControlTransport
control_transport
;
332
333
/* Number of RTCP BYE packets the RTSP session has received.
334
* An EOF is propagated back if nb_byes == nb_streams.
335
* This is reset after a seek. */
336
int
nb_byes
;
337
338
/** Reusable buffer for receiving packets */
339
uint8_t
*
recvbuf
;
340
341
/**
342
* A mask with all requested transport methods
343
*/
344
int
lower_transport_mask
;
345
346
/**
347
* The number of returned packets
348
*/
349
uint64_t
packets
;
350
351
/**
352
* Polling array for udp
353
*/
354
struct
pollfd *
p
;
355
356
/**
357
* Whether the server supports the GET_PARAMETER method.
358
*/
359
int
get_parameter_supported
;
360
361
/**
362
* Do not begin to play the stream immediately.
363
*/
364
int
initial_pause
;
365
366
/**
367
* Option flags for the chained RTP muxer.
368
*/
369
int
rtp_muxer_flags
;
370
371
/** Whether the server accepts the x-Dynamic-Rate header */
372
int
accept_dynamic_rate
;
373
374
/**
375
* Various option flags for the RTSP muxer/demuxer.
376
*/
377
int
rtsp_flags
;
378
379
/**
380
* Mask of all requested media types
381
*/
382
int
media_type_mask
;
383
384
/**
385
* Minimum and maximum local UDP ports.
386
*/
387
int
rtp_port_min
,
rtp_port_max
;
388
389
/**
390
* Timeout to wait for incoming connections.
391
*/
392
int
initial_timeout
;
393
394
/**
395
* timeout of socket i/o operations.
396
*/
397
int
stimeout
;
398
399
/**
400
* Size of RTP packet reordering queue.
401
*/
402
int
reordering_queue_size
;
403
404
/**
405
* User-Agent string
406
*/
407
char
*
user_agent
;
408
}
RTSPState
;
409
410
#define RTSP_FLAG_FILTER_SRC 0x1
/**< Filter incoming UDP packets -
411
receive packets only from the right
412
source address and port. */
413
#define RTSP_FLAG_LISTEN 0x2
/**< Wait for incoming connections. */
414
#define RTSP_FLAG_CUSTOM_IO 0x4
/**< Do all IO via the AVIOContext. */
415
#define RTSP_FLAG_RTCP_TO_SOURCE 0x8
/**< Send RTCP packets to the source
416
address of received packets. */
417
#define RTSP_FLAG_PREFER_TCP 0x10
/**< Try RTP via TCP first if possible. */
418
419
typedef
struct
RTSPSource
{
420
char
addr
[128];
/**< Source-specific multicast include source IP address (from SDP content) */
421
}
RTSPSource
;
422
423
/**
424
* Describe a single stream, as identified by a single m= line block in the
425
* SDP content. In the case of RDT, one RTSPStream can represent multiple
426
* AVStreams. In this case, each AVStream in this set has similar content
427
* (but different codec/bitrate).
428
*/
429
typedef
struct
RTSPStream
{
430
URLContext
*
rtp_handle
;
/**< RTP stream handle (if UDP) */
431
void
*
transport_priv
;
/**< RTP/RDT parse context if input, RTP AVFormatContext if output */
432
433
/** corresponding stream index, if any. -1 if none (MPEG2TS case) */
434
int
stream_index
;
435
436
/** interleave IDs; copies of RTSPTransportField->interleaved_min/max
437
* for the selected transport. Only used for TCP. */
438
int
interleaved_min
,
interleaved_max
;
439
440
char
control_url
[1024];
/**< url for this stream (from SDP) */
441
442
/** The following are used only in SDP, not RTSP */
443
//@{
444
int
sdp_port
;
/**< port (from SDP content) */
445
struct
sockaddr_storage
sdp_ip
;
/**< IP address (from SDP content) */
446
int
nb_include_source_addrs
;
/**< Number of source-specific multicast include source IP addresses (from SDP content) */
447
struct
RTSPSource
**
include_source_addrs
;
/**< Source-specific multicast include source IP addresses (from SDP content) */
448
int
nb_exclude_source_addrs
;
/**< Number of source-specific multicast exclude source IP addresses (from SDP content) */
449
struct
RTSPSource
**
exclude_source_addrs
;
/**< Source-specific multicast exclude source IP addresses (from SDP content) */
450
int
sdp_ttl
;
/**< IP Time-To-Live (from SDP content) */
451
int
sdp_payload_type
;
/**< payload type */
452
//@}
453
454
/** The following are used for dynamic protocols (rtpdec_*.c/rdt.c) */
455
//@{
456
/** handler structure */
457
RTPDynamicProtocolHandler
*
dynamic_handler
;
458
459
/** private data associated with the dynamic protocol */
460
PayloadContext
*
dynamic_protocol_context
;
461
//@}
462
463
/** Enable sending RTCP feedback messages according to RFC 4585 */
464
int
feedback
;
465
466
char
crypto_suite
[40];
467
char
crypto_params
[100];
468
}
RTSPStream
;
469
470
void
ff_rtsp_parse_line
(
RTSPMessageHeader
*reply,
const
char
*
buf
,
471
RTSPState
*rt,
const
char
*method);
472
473
/**
474
* Send a command to the RTSP server without waiting for the reply.
475
*
476
* @see rtsp_send_cmd_with_content_async
477
*/
478
int
ff_rtsp_send_cmd_async
(
AVFormatContext
*
s
,
const
char
*method,
479
const
char
*url,
const
char
*headers);
480
481
/**
482
* Send a command to the RTSP server and wait for the reply.
483
*
484
* @param s RTSP (de)muxer context
485
* @param method the method for the request
486
* @param url the target url for the request
487
* @param headers extra header lines to include in the request
488
* @param reply pointer where the RTSP message header will be stored
489
* @param content_ptr pointer where the RTSP message body, if any, will
490
* be stored (length is in reply)
491
* @param send_content if non-null, the data to send as request body content
492
* @param send_content_length the length of the send_content data, or 0 if
493
* send_content is null
494
*
495
* @return zero if success, nonzero otherwise
496
*/
497
int
ff_rtsp_send_cmd_with_content
(
AVFormatContext
*
s
,
498
const
char
*method,
const
char
*url,
499
const
char
*headers,
500
RTSPMessageHeader
*reply,
501
unsigned
char
**content_ptr,
502
const
unsigned
char
*send_content,
503
int
send_content_length);
504
505
/**
506
* Send a command to the RTSP server and wait for the reply.
507
*
508
* @see rtsp_send_cmd_with_content
509
*/
510
int
ff_rtsp_send_cmd
(
AVFormatContext
*
s
,
const
char
*method,
511
const
char
*url,
const
char
*headers,
512
RTSPMessageHeader
*reply,
unsigned
char
**content_ptr);
513
514
/**
515
* Read a RTSP message from the server, or prepare to read data
516
* packets if we're reading data interleaved over the TCP/RTSP
517
* connection as well.
518
*
519
* @param s RTSP (de)muxer context
520
* @param reply pointer where the RTSP message header will be stored
521
* @param content_ptr pointer where the RTSP message body, if any, will
522
* be stored (length is in reply)
523
* @param return_on_interleaved_data whether the function may return if we
524
* encounter a data marker ('$'), which precedes data
525
* packets over interleaved TCP/RTSP connections. If this
526
* is set, this function will return 1 after encountering
527
* a '$'. If it is not set, the function will skip any
528
* data packets (if they are encountered), until a reply
529
* has been fully parsed. If no more data is available
530
* without parsing a reply, it will return an error.
531
* @param method the RTSP method this is a reply to. This affects how
532
* some response headers are acted upon. May be NULL.
533
*
534
* @return 1 if a data packets is ready to be received, -1 on error,
535
* and 0 on success.
536
*/
537
int
ff_rtsp_read_reply
(
AVFormatContext
*
s
,
RTSPMessageHeader
*reply,
538
unsigned
char
**content_ptr,
539
int
return_on_interleaved_data,
const
char
*method);
540
541
/**
542
* Skip a RTP/TCP interleaved packet.
543
*/
544
void
ff_rtsp_skip_packet
(
AVFormatContext
*
s
);
545
546
/**
547
* Connect to the RTSP server and set up the individual media streams.
548
* This can be used for both muxers and demuxers.
549
*
550
* @param s RTSP (de)muxer context
551
*
552
* @return 0 on success, < 0 on error. Cleans up all allocations done
553
* within the function on error.
554
*/
555
int
ff_rtsp_connect
(
AVFormatContext
*
s
);
556
557
/**
558
* Close and free all streams within the RTSP (de)muxer
559
*
560
* @param s RTSP (de)muxer context
561
*/
562
void
ff_rtsp_close_streams
(
AVFormatContext
*
s
);
563
564
/**
565
* Close all connection handles within the RTSP (de)muxer
566
*
567
* @param s RTSP (de)muxer context
568
*/
569
void
ff_rtsp_close_connections
(
AVFormatContext
*
s
);
570
571
/**
572
* Get the description of the stream and set up the RTSPStream child
573
* objects.
574
*/
575
int
ff_rtsp_setup_input_streams
(
AVFormatContext
*
s
,
RTSPMessageHeader
*reply);
576
577
/**
578
* Announce the stream to the server and set up the RTSPStream child
579
* objects for each media stream.
580
*/
581
int
ff_rtsp_setup_output_streams
(
AVFormatContext
*
s
,
const
char
*
addr
);
582
583
/**
584
* Parse RTSP commands (OPTIONS, PAUSE and TEARDOWN) during streaming in
585
* listen mode.
586
*/
587
int
ff_rtsp_parse_streaming_commands
(
AVFormatContext
*
s
);
588
589
/**
590
* Parse an SDP description of streams by populating an RTSPState struct
591
* within the AVFormatContext; also allocate the RTP streams and the
592
* pollfd array used for UDP streams.
593
*/
594
int
ff_sdp_parse
(
AVFormatContext
*
s
,
const
char
*content);
595
596
/**
597
* Receive one RTP packet from an TCP interleaved RTSP stream.
598
*/
599
int
ff_rtsp_tcp_read_packet
(
AVFormatContext
*
s
,
RTSPStream
**prtsp_st,
600
uint8_t
*
buf
,
int
buf_size);
601
602
/**
603
* Send buffered packets over TCP.
604
*/
605
int
ff_rtsp_tcp_write_packet
(
AVFormatContext
*
s
,
RTSPStream
*rtsp_st);
606
607
/**
608
* Receive one packet from the RTSPStreams set up in the AVFormatContext
609
* (which should contain a RTSPState struct as priv_data).
610
*/
611
int
ff_rtsp_fetch_packet
(
AVFormatContext
*
s
,
AVPacket
*
pkt
);
612
613
/**
614
* Do the SETUP requests for each stream for the chosen
615
* lower transport mode.
616
* @return 0 on success, <0 on error, 1 if protocol is unavailable
617
*/
618
int
ff_rtsp_make_setup_request
(
AVFormatContext
*
s
,
const
char
*host,
int
port,
619
int
lower_transport,
const
char
*real_challenge);
620
621
/**
622
* Undo the effect of ff_rtsp_make_setup_request, close the
623
* transport_priv and rtp_handle fields.
624
*/
625
void
ff_rtsp_undo_setup
(
AVFormatContext
*
s
,
int
send_packets);
626
627
/**
628
* Open RTSP transport context.
629
*/
630
int
ff_rtsp_open_transport_ctx
(
AVFormatContext
*
s
,
RTSPStream
*rtsp_st);
631
632
extern
const
AVOption
ff_rtsp_options
[];
633
634
#endif
/* AVFORMAT_RTSP_H */
Generated on Fri Dec 5 2014 04:42:14 for FFmpeg by
1.8.2