Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtp.h @ 1a45a9f4

History | View | Annotate | Download (7.7 KB)

1
/*
2
 * RTP definitions
3
 * Copyright (c) 2002 Fabrice Bellard
4
 * Copyright (c) 2006 Ryan Martell <rdm4@martellventures.com>
5
 *
6
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 * Lesser General Public License for more details.
17
 *
18
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
22
#ifndef AVFORMAT_RTP_H
23
#define AVFORMAT_RTP_H
24

    
25
#include "libavcodec/avcodec.h"
26
#include "avformat.h"
27

    
28
/** Structure listing useful vars to parse RTP packet payload*/
29
typedef struct rtp_payload_data
30
{
31
    int sizelength;
32
    int indexlength;
33
    int indexdeltalength;
34
    int profile_level_id;
35
    int streamtype;
36
    int objecttype;
37
    char *mode;
38

    
39
    /** mpeg 4 AU headers */
40
    struct AUHeaders {
41
        int size;
42
        int index;
43
        int cts_flag;
44
        int cts;
45
        int dts_flag;
46
        int dts;
47
        int rap_flag;
48
        int streamstate;
49
    } *au_headers;
50
    int nb_au_headers;
51
    int au_headers_length_bytes;
52
    int cur_au_index;
53
} RTPPayloadData;
54

    
55
typedef struct PayloadContext PayloadContext;
56
typedef struct RTPDynamicProtocolHandler_s RTPDynamicProtocolHandler;
57

    
58
#define RTP_MIN_PACKET_LENGTH 12
59
#define RTP_MAX_PACKET_LENGTH 1500 /* XXX: suppress this define */
60

    
61
int rtp_get_codec_info(AVCodecContext *codec, int payload_type);
62

    
63
/** return < 0 if unknown payload type */
64
int rtp_get_payload_type(AVCodecContext *codec);
65

    
66
typedef struct RTPDemuxContext RTPDemuxContext;
67
RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, URLContext *rtpc, int payload_type, RTPPayloadData *rtp_payload_data);
68
void rtp_parse_set_dynamic_protocol(RTPDemuxContext *s, PayloadContext *ctx,
69
                                    RTPDynamicProtocolHandler *handler);
70
int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
71
                     const uint8_t *buf, int len);
72
void rtp_parse_close(RTPDemuxContext *s);
73

    
74
int rtp_get_local_port(URLContext *h);
75
int rtp_set_remote_url(URLContext *h, const char *uri);
76
void rtp_get_file_handles(URLContext *h, int *prtp_fd, int *prtcp_fd);
77

    
78
/**
79
 * some rtp servers assume client is dead if they don't hear from them...
80
 * so we send a Receiver Report to the provided ByteIO context
81
 * (we don't have access to the rtcp handle from here)
82
 */
83
int rtp_check_and_send_back_rr(RTPDemuxContext *s, int count);
84

    
85
#define RTP_PT_PRIVATE 96
86
#define RTP_VERSION 2
87
#define RTP_MAX_SDES 256   /**< maximum text length for SDES */
88

    
89
/* RTCP paquets use 0.5 % of the bandwidth */
90
#define RTCP_TX_RATIO_NUM 5
91
#define RTCP_TX_RATIO_DEN 1000
92

    
93
// these statistics are used for rtcp receiver reports...
94
typedef struct {
95
    uint16_t max_seq;           ///< highest sequence number seen
96
    uint32_t cycles;            ///< shifted count of sequence number cycles
97
    uint32_t base_seq;          ///< base sequence number
98
    uint32_t bad_seq;           ///< last bad sequence number + 1
99
    int probation;              ///< sequence packets till source is valid
100
    int received;               ///< packets received
101
    int expected_prior;         ///< packets expected in last interval
102
    int received_prior;         ///< packets received in last interval
103
    uint32_t transit;           ///< relative transit time for previous packet
104
    uint32_t jitter;            ///< estimated jitter.
105
} RTPStatistics;
106

    
107
/**
108
 * Packet parsing for "private" payloads in the RTP specs.
109
 *
110
 * @param ctx RTSP demuxer context
111
 * @param s stream context
112
 * @param st stream that this packet belongs to
113
 * @param pkt packet in which to write the parsed data
114
 * @param timestamp pointer in which to write the timestamp of this RTP packet
115
 * @param buf pointer to raw RTP packet data
116
 * @param len length of buf
117
 * @param flags flags from the RTP packet header (PKT_FLAG_*)
118
 */
119
typedef int (*DynamicPayloadPacketHandlerProc) (AVFormatContext *ctx,
120
                                                PayloadContext *s,
121
                                                AVStream *st,
122
                                                AVPacket * pkt,
123
                                                uint32_t *timestamp,
124
                                                const uint8_t * buf,
125
                                                int len, int flags);
126

    
127
struct RTPDynamicProtocolHandler_s {
128
    // fields from AVRtpDynamicPayloadType_s
129
    const char enc_name[50];    /* XXX: still why 50 ? ;-) */
130
    enum CodecType codec_type;
131
    enum CodecID codec_id;
132

    
133
    // may be null
134
    int (*parse_sdp_a_line) (AVFormatContext *s,
135
                             int st_index,
136
                             PayloadContext *priv_data,
137
                             const char *line); ///< Parse the a= line from the sdp field
138
    PayloadContext *(*open) (); ///< allocate any data needed by the rtp parsing for this dynamic data.
139
    void (*close)(PayloadContext *protocol_data); ///< free any data needed by the rtp parsing for this dynamic data.
140
    DynamicPayloadPacketHandlerProc parse_packet; ///< parse handler for this dynamic packet.
141

    
142
    struct RTPDynamicProtocolHandler_s *next;
143
};
144

    
145
// moved out of rtp.c, because the h264 decoder needs to know about this structure..
146
struct RTPDemuxContext {
147
    AVFormatContext *ic;
148
    AVStream *st;
149
    int payload_type;
150
    uint32_t ssrc;
151
    uint16_t seq;
152
    uint32_t timestamp;
153
    uint32_t base_timestamp;
154
    uint32_t cur_timestamp;
155
    int max_payload_size;
156
    struct MpegTSContext *ts;   /* only used for MP2T payloads */
157
    int read_buf_index;
158
    int read_buf_size;
159
    int num_frames;
160
    /* used to send back RTCP RR */
161
    URLContext *rtp_ctx;
162
    char hostname[256];
163

    
164
    RTPStatistics statistics; ///< Statistics for this stream (used by RTCP receiver reports)
165

    
166
    /* rtcp sender statistics receive */
167
    int64_t last_rtcp_ntp_time;    // TODO: move into statistics
168
    int64_t first_rtcp_ntp_time;   // TODO: move into statistics
169
    uint32_t last_rtcp_timestamp;  // TODO: move into statistics
170

    
171
    /* rtcp sender statistics */
172
    unsigned int packet_count;     // TODO: move into statistics (outgoing)
173
    unsigned int octet_count;      // TODO: move into statistics (outgoing)
174
    unsigned int last_octet_count; // TODO: move into statistics (outgoing)
175
    int first_packet;
176
    /* buffer for output */
177
    uint8_t buf[RTP_MAX_PACKET_LENGTH];
178
    uint8_t *buf_ptr;
179

    
180
    /* special infos for au headers parsing */
181
    RTPPayloadData *rtp_payload_data; // TODO: Move into dynamic payload handlers
182

    
183
    /* dynamic payload stuff */
184
    DynamicPayloadPacketHandlerProc parse_packet;     ///< This is also copied from the dynamic protocol handler structure
185
    PayloadContext *dynamic_protocol_context;        ///< This is a copy from the values setup from the sdp parsing, in rtsp.c don't free me.
186
    int max_frames_per_packet;
187
};
188

    
189
extern RTPDynamicProtocolHandler *RTPFirstDynamicPayloadHandler;
190
void ff_register_dynamic_payload_handler(RTPDynamicProtocolHandler *handler);
191

    
192
int rtsp_next_attr_and_value(const char **p, char *attr, int attr_size, char *value, int value_size); ///< from rtsp.c, but used by rtp dynamic protocol handlers.
193

    
194
void ff_rtp_send_data(AVFormatContext *s1, const uint8_t *buf1, int len, int m);
195
const char *ff_rtp_enc_name(int payload_type);
196
enum CodecID ff_rtp_codec_id(const char *buf, enum CodecType codec_type);
197

    
198
void av_register_rtp_dynamic_payload_handlers(void);
199

    
200
#endif /* AVFORMAT_RTP_H */