Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * RTMP packet utilities | |
3 | * Copyright (c) 2009 Konstantin Shishkov | |
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 | ||
22 | #ifndef AVFORMAT_RTMPPKT_H | |
23 | #define AVFORMAT_RTMPPKT_H | |
24 | ||
25 | #include "libavcodec/bytestream.h" | |
26 | #include "avformat.h" | |
27 | #include "url.h" | |
28 | ||
29 | /** maximum possible number of different RTMP channels */ | |
30 | #define RTMP_CHANNELS 65599 | |
31 | ||
32 | /** | |
33 | * channels used to for RTMP packets with different purposes (i.e. data, network | |
34 | * control, remote procedure calls, etc.) | |
35 | */ | |
36 | enum RTMPChannel { | |
37 | RTMP_NETWORK_CHANNEL = 2, ///< channel for network-related messages (bandwidth report, ping, etc) | |
38 | RTMP_SYSTEM_CHANNEL, ///< channel for sending server control messages | |
39 | RTMP_AUDIO_CHANNEL, ///< channel for audio data | |
40 | RTMP_VIDEO_CHANNEL = 6, ///< channel for video data | |
41 | RTMP_SOURCE_CHANNEL = 8, ///< channel for a/v invokes | |
42 | }; | |
43 | ||
44 | /** | |
45 | * known RTMP packet types | |
46 | */ | |
47 | typedef enum RTMPPacketType { | |
48 | RTMP_PT_CHUNK_SIZE = 1, ///< chunk size change | |
49 | RTMP_PT_BYTES_READ = 3, ///< number of bytes read | |
50 | RTMP_PT_PING, ///< ping | |
51 | RTMP_PT_SERVER_BW, ///< server bandwidth | |
52 | RTMP_PT_CLIENT_BW, ///< client bandwidth | |
53 | RTMP_PT_AUDIO = 8, ///< audio packet | |
54 | RTMP_PT_VIDEO, ///< video packet | |
55 | RTMP_PT_FLEX_STREAM = 15, ///< Flex shared stream | |
56 | RTMP_PT_FLEX_OBJECT, ///< Flex shared object | |
57 | RTMP_PT_FLEX_MESSAGE, ///< Flex shared message | |
58 | RTMP_PT_NOTIFY, ///< some notification | |
59 | RTMP_PT_SHARED_OBJ, ///< shared object | |
60 | RTMP_PT_INVOKE, ///< invoke some stream action | |
61 | RTMP_PT_METADATA = 22, ///< FLV metadata | |
62 | } RTMPPacketType; | |
63 | ||
64 | /** | |
65 | * possible RTMP packet header sizes | |
66 | */ | |
67 | enum RTMPPacketSize { | |
68 | RTMP_PS_TWELVEBYTES = 0, ///< packet has 12-byte header | |
69 | RTMP_PS_EIGHTBYTES, ///< packet has 8-byte header | |
70 | RTMP_PS_FOURBYTES, ///< packet has 4-byte header | |
71 | RTMP_PS_ONEBYTE ///< packet is really a next chunk of a packet | |
72 | }; | |
73 | ||
74 | /** | |
75 | * structure for holding RTMP packets | |
76 | */ | |
77 | typedef struct RTMPPacket { | |
78 | int channel_id; ///< RTMP channel ID (nothing to do with audio/video channels though) | |
79 | RTMPPacketType type; ///< packet payload type | |
80 | uint32_t timestamp; ///< packet full timestamp | |
81 | uint32_t ts_field; ///< 24-bit timestamp or increment to the previous one, in milliseconds (latter only for media packets). Clipped to a maximum of 0xFFFFFF, indicating an extended timestamp field. | |
82 | uint32_t extra; ///< probably an additional channel ID used during streaming data | |
83 | uint8_t *data; ///< packet payload | |
84 | int size; ///< packet payload size | |
85 | int offset; ///< amount of data read so far | |
86 | int read; ///< amount read, including headers | |
87 | } RTMPPacket; | |
88 | ||
89 | /** | |
90 | * Create new RTMP packet with given attributes. | |
91 | * | |
92 | * @param pkt packet | |
93 | * @param channel_id packet channel ID | |
94 | * @param type packet type | |
95 | * @param timestamp packet timestamp | |
96 | * @param size packet size | |
97 | * @return zero on success, negative value otherwise | |
98 | */ | |
99 | int ff_rtmp_packet_create(RTMPPacket *pkt, int channel_id, RTMPPacketType type, | |
100 | int timestamp, int size); | |
101 | ||
102 | /** | |
103 | * Free RTMP packet. | |
104 | * | |
105 | * @param pkt packet | |
106 | */ | |
107 | void ff_rtmp_packet_destroy(RTMPPacket *pkt); | |
108 | ||
109 | /** | |
110 | * Read RTMP packet sent by the server. | |
111 | * | |
112 | * @param h reader context | |
113 | * @param p packet | |
114 | * @param chunk_size current chunk size | |
115 | * @param prev_pkt previously read packet headers for all channels | |
116 | * (may be needed for restoring incomplete packet header) | |
117 | * @param nb_prev_pkt number of allocated elements in prev_pkt | |
118 | * @return number of bytes read on success, negative value otherwise | |
119 | */ | |
120 | int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p, | |
121 | int chunk_size, RTMPPacket **prev_pkt, | |
122 | int *nb_prev_pkt); | |
123 | /** | |
124 | * Read internal RTMP packet sent by the server. | |
125 | * | |
126 | * @param h reader context | |
127 | * @param p packet | |
128 | * @param chunk_size current chunk size | |
129 | * @param prev_pkt previously read packet headers for all channels | |
130 | * (may be needed for restoring incomplete packet header) | |
131 | * @param nb_prev_pkt number of allocated elements in prev_pkt | |
132 | * @param c the first byte already read | |
133 | * @return number of bytes read on success, negative value otherwise | |
134 | */ | |
135 | int ff_rtmp_packet_read_internal(URLContext *h, RTMPPacket *p, int chunk_size, | |
136 | RTMPPacket **prev_pkt, int *nb_prev_pkt, | |
137 | uint8_t c); | |
138 | ||
139 | /** | |
140 | * Send RTMP packet to the server. | |
141 | * | |
142 | * @param h reader context | |
143 | * @param p packet to send | |
144 | * @param chunk_size current chunk size | |
145 | * @param prev_pkt previously sent packet headers for all channels | |
146 | * (may be used for packet header compressing) | |
147 | * @param nb_prev_pkt number of allocated elements in prev_pkt | |
148 | * @return number of bytes written on success, negative value otherwise | |
149 | */ | |
150 | int ff_rtmp_packet_write(URLContext *h, RTMPPacket *p, | |
151 | int chunk_size, RTMPPacket **prev_pkt, | |
152 | int *nb_prev_pkt); | |
153 | ||
154 | /** | |
155 | * Print information and contents of RTMP packet. | |
156 | * | |
157 | * @param ctx output context | |
158 | * @param p packet to dump | |
159 | */ | |
160 | void ff_rtmp_packet_dump(void *ctx, RTMPPacket *p); | |
161 | ||
162 | /** | |
163 | * Enlarge the prev_pkt array to fit the given channel | |
164 | * | |
165 | * @param prev_pkt array with previously sent packet headers | |
166 | * @param nb_prev_pkt number of allocated elements in prev_pkt | |
167 | * @param channel the channel number that needs to be allocated | |
168 | */ | |
169 | int ff_rtmp_check_alloc_array(RTMPPacket **prev_pkt, int *nb_prev_pkt, | |
170 | int channel); | |
171 | ||
172 | /** | |
173 | * @name Functions used to work with the AMF format (which is also used in .flv) | |
174 | * @see amf_* funcs in libavformat/flvdec.c | |
175 | * @{ | |
176 | */ | |
177 | ||
178 | /** | |
179 | * Calculate number of bytes taken by first AMF entry in data. | |
180 | * | |
181 | * @param data input data | |
182 | * @param data_end input buffer end | |
183 | * @return number of bytes used by first AMF entry | |
184 | */ | |
185 | int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end); | |
186 | ||
187 | /** | |
188 | * Retrieve value of given AMF object field in string form. | |
189 | * | |
190 | * @param data AMF object data | |
191 | * @param data_end input buffer end | |
192 | * @param name name of field to retrieve | |
193 | * @param dst buffer for storing result | |
194 | * @param dst_size output buffer size | |
195 | * @return 0 if search and retrieval succeeded, negative value otherwise | |
196 | */ | |
197 | int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end, | |
198 | const uint8_t *name, uint8_t *dst, int dst_size); | |
199 | ||
200 | /** | |
201 | * Write boolean value in AMF format to buffer. | |
202 | * | |
203 | * @param dst pointer to the input buffer (will be modified) | |
204 | * @param val value to write | |
205 | */ | |
206 | void ff_amf_write_bool(uint8_t **dst, int val); | |
207 | ||
208 | /** | |
209 | * Write number in AMF format to buffer. | |
210 | * | |
211 | * @param dst pointer to the input buffer (will be modified) | |
212 | * @param num value to write | |
213 | */ | |
214 | void ff_amf_write_number(uint8_t **dst, double num); | |
215 | ||
216 | /** | |
217 | * Write string in AMF format to buffer. | |
218 | * | |
219 | * @param dst pointer to the input buffer (will be modified) | |
220 | * @param str string to write | |
221 | */ | |
222 | void ff_amf_write_string(uint8_t **dst, const char *str); | |
223 | ||
224 | /** | |
225 | * Write a string consisting of two parts in AMF format to a buffer. | |
226 | * | |
227 | * @param dst pointer to the input buffer (will be modified) | |
228 | * @param str1 first string to write, may be null | |
229 | * @param str2 second string to write, may be null | |
230 | */ | |
231 | void ff_amf_write_string2(uint8_t **dst, const char *str1, const char *str2); | |
232 | ||
233 | /** | |
234 | * Write AMF NULL value to buffer. | |
235 | * | |
236 | * @param dst pointer to the input buffer (will be modified) | |
237 | */ | |
238 | void ff_amf_write_null(uint8_t **dst); | |
239 | ||
240 | /** | |
241 | * Write marker for AMF object to buffer. | |
242 | * | |
243 | * @param dst pointer to the input buffer (will be modified) | |
244 | */ | |
245 | void ff_amf_write_object_start(uint8_t **dst); | |
246 | ||
247 | /** | |
248 | * Write string used as field name in AMF object to buffer. | |
249 | * | |
250 | * @param dst pointer to the input buffer (will be modified) | |
251 | * @param str string to write | |
252 | */ | |
253 | void ff_amf_write_field_name(uint8_t **dst, const char *str); | |
254 | ||
255 | /** | |
256 | * Write marker for end of AMF object to buffer. | |
257 | * | |
258 | * @param dst pointer to the input buffer (will be modified) | |
259 | */ | |
260 | void ff_amf_write_object_end(uint8_t **dst); | |
261 | ||
262 | /** | |
263 | * Read AMF boolean value. | |
264 | * | |
265 | *@param[in,out] gbc GetByteContext initialized with AMF-formatted data | |
266 | *@param[out] val 0 or 1 | |
267 | *@return 0 on success or an AVERROR code on failure | |
268 | */ | |
269 | int ff_amf_read_bool(GetByteContext *gbc, int *val); | |
270 | ||
271 | /** | |
272 | * Read AMF number value. | |
273 | * | |
274 | *@param[in,out] gbc GetByteContext initialized with AMF-formatted data | |
275 | *@param[out] val read value | |
276 | *@return 0 on success or an AVERROR code on failure | |
277 | */ | |
278 | int ff_amf_read_number(GetByteContext *gbc, double *val); | |
279 | ||
280 | /** | |
281 | * Get AMF string value. | |
282 | * | |
283 | * This function behaves the same as ff_amf_read_string except that | |
284 | * it does not expect the AMF type prepended to the actual data. | |
285 | * Appends a trailing null byte to output string in order to | |
286 | * ease later parsing. | |
287 | * | |
288 | *@param[in,out] gbc GetByteContext initialized with AMF-formatted data | |
289 | *@param[out] str read string | |
290 | *@param[in] strsize buffer size available to store the read string | |
291 | *@param[out] length read string length | |
292 | *@return 0 on success or an AVERROR code on failure | |
293 | */ | |
294 | int ff_amf_get_string(GetByteContext *bc, uint8_t *str, | |
295 | int strsize, int *length); | |
296 | ||
297 | /** | |
298 | * Read AMF string value. | |
299 | * | |
300 | * Appends a trailing null byte to output string in order to | |
301 | * ease later parsing. | |
302 | * | |
303 | *@param[in,out] gbc GetByteContext initialized with AMF-formatted data | |
304 | *@param[out] str read string | |
305 | *@param[in] strsize buffer size available to store the read string | |
306 | *@param[out] length read string length | |
307 | *@return 0 on success or an AVERROR code on failure | |
308 | */ | |
309 | int ff_amf_read_string(GetByteContext *gbc, uint8_t *str, | |
310 | int strsize, int *length); | |
311 | ||
312 | /** | |
313 | * Read AMF NULL value. | |
314 | * | |
315 | *@param[in,out] gbc GetByteContext initialized with AMF-formatted data | |
316 | *@return 0 on success or an AVERROR code on failure | |
317 | */ | |
318 | int ff_amf_read_null(GetByteContext *gbc); | |
319 | ||
320 | /** | |
321 | * Match AMF string with a NULL-terminated string. | |
322 | * | |
323 | * @return 0 if the strings do not match. | |
324 | */ | |
325 | ||
326 | int ff_amf_match_string(const uint8_t *data, int size, const char *str); | |
327 | ||
328 | /** @} */ // AMF funcs | |
329 | ||
330 | #endif /* AVFORMAT_RTMPPKT_H */ |