1. ffmpeg
  2. Commit 9fd6b8436008100699537c76e28c21a01e58cf4c
Browse code

RTMP protocol support (as a client)

Originally committed as revision 19556 to svn://svn.ffmpeg.org/ffmpeg/trunk

Kostya Shishkov authored on 2009/07/31 15:49:36
Showing 9 changed files
Changelog
History View file @ 9fd6b84
... ... 
@@ -29,6 +29,7 @@ version <next>:
29 29 
 - nonfree libamr support for AMR-NB/WB decoding/encoding removed
30 30 
 - Experimental AAC encoder
31 31 
 - RTP depacketization of ASF and RTSP from WMS servers
32 
+- RTMP support in libavformat
32 33
33 34
34 35
doc/general.texi
History View file @ 9fd6b84
... ... 
@@ -195,6 +195,7 @@ library:
195 195 
 @item RL2                       @tab   @tab X
196 196 
     @tab Audio and video format used in some games by Entertainment Software Partners.
197 197 
 @item RPL/ARMovie               @tab   @tab X
198 
+@item RTMP                      @tab   @tab X
198 199 
 @item RTP                       @tab   @tab X
199 200 
 @item RTSP                      @tab   @tab X
200 201 
 @item SDP                       @tab   @tab X
libavformat/Makefile
History View file @ 9fd6b84
... ... 
@@ -237,6 +237,7 @@ OBJS-$(CONFIG_FILE_PROTOCOL)             += file.o
237 237 
 OBJS-$(CONFIG_GOPHER_PROTOCOL)           += gopher.o
238 238 
 OBJS-$(CONFIG_HTTP_PROTOCOL)             += http.o
239 239 
 OBJS-$(CONFIG_PIPE_PROTOCOL)             += file.o
240 
+OBJS-$(CONFIG_RTMP_PROTOCOL)             += rtmpproto.o rtmppkt.o
240 241 
 OBJS-$(CONFIG_RTP_PROTOCOL)              += rtpproto.o
241 242 
 OBJS-$(CONFIG_TCP_PROTOCOL)              += tcp.o
242 243 
 OBJS-$(CONFIG_UDP_PROTOCOL)              += udp.o
libavformat/allformats.c
History View file @ 9fd6b84
... ... 
@@ -209,6 +209,7 @@ void av_register_all(void)
209 209 
     REGISTER_PROTOCOL (GOPHER, gopher);
210 210 
     REGISTER_PROTOCOL (HTTP, http);
211 211 
     REGISTER_PROTOCOL (PIPE, pipe);
212 
+    REGISTER_PROTOCOL (RTMP, rtmp);
212 213 
     REGISTER_PROTOCOL (RTP, rtp);
213 214 
     REGISTER_PROTOCOL (TCP, tcp);
214 215 
     REGISTER_PROTOCOL (UDP, udp);
libavformat/avformat.h
History View file @ 9fd6b84
... ... 
@@ -22,7 +22,7 @@
22 22 
 #define AVFORMAT_AVFORMAT_H
23 23
24 24 
 #define LIBAVFORMAT_VERSION_MAJOR 52
25 
-#define LIBAVFORMAT_VERSION_MINOR 36
25 
+#define LIBAVFORMAT_VERSION_MINOR 37
26 26 
 #define LIBAVFORMAT_VERSION_MICRO  0
27 27
28 28 
 #define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
libavformat/rtmp.h
History View file @ 9fd6b84
29 29 
new file mode 100644
... ... 
@@ -0,0 +1,42 @@
0 
+/*
1 
+ * RTMP definitions
2 
+ * Copyright (c) 2009 Kostya Shishkov
3 
+ *
4 
+ * This file is part of FFmpeg.
5 
+ *
6 
+ * FFmpeg is free software; you can redistribute it and/or
7 
+ * modify it under the terms of the GNU Lesser General Public
8 
+ * License as published by the Free Software Foundation; either
9 
+ * version 2.1 of the License, or (at your option) any later version.
10 
+ *
11 
+ * FFmpeg is distributed in the hope that it will be useful,
12 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 
+ * Lesser General Public License for more details.
15 
+ *
16 
+ * You should have received a copy of the GNU Lesser General Public
17 
+ * License along with FFmpeg; if not, write to the Free Software
18 
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 
+ */
20 
+
21 
+#ifndef AVFORMAT_RTMP_H
22 
+#define AVFORMAT_RTMP_H
23 
+
24 
+#include "avformat.h"
25 
+
26 
+#define RTMP_DEFAULT_PORT 1935
27 
+
28 
+#define RTMP_HANDSHAKE_PACKET_SIZE 1536
29 
+
30 
+/**
31 
+ * emulated Flash client version - 9.0.124.2 on Linux
32 
+ * @{
33 
+ */
34 
+#define RTMP_CLIENT_PLATFORM "LNX"
35 
+#define RTMP_CLIENT_VER1    9
36 
+#define RTMP_CLIENT_VER2    0
37 
+#define RTMP_CLIENT_VER3  124
38 
+#define RTMP_CLIENT_VER4    2
39 
+/** @} */ //version defines
40 
+
41 
+#endif /* AVFORMAT_RTMP_H */
libavformat/rtmppkt.c
History View file @ 9fd6b84
0 42 
new file mode 100644
... ... 
@@ -0,0 +1,265 @@
0 
+/*
1 
+ * RTMP input format
2 
+ * Copyright (c) 2009 Kostya Shishkov
3 
+ *
4 
+ * This file is part of FFmpeg.
5 
+ *
6 
+ * FFmpeg is free software; you can redistribute it and/or
7 
+ * modify it under the terms of the GNU Lesser General Public
8 
+ * License as published by the Free Software Foundation; either
9 
+ * version 2.1 of the License, or (at your option) any later version.
10 
+ *
11 
+ * FFmpeg is distributed in the hope that it will be useful,
12 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 
+ * Lesser General Public License for more details.
15 
+ *
16 
+ * You should have received a copy of the GNU Lesser General Public
17 
+ * License along with FFmpeg; if not, write to the Free Software
18 
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 
+ */
20 
+
21 
+#include "libavcodec/bytestream.h"
22 
+#include "libavutil/avstring.h"
23 
+#include "avformat.h"
24 
+
25 
+#include "rtmppkt.h"
26 
+#include "flv.h"
27 
+
28 
+void ff_amf_write_bool(uint8_t **dst, int val)
29 
+{
30 
+    bytestream_put_byte(dst, AMF_DATA_TYPE_BOOL);
31 
+    bytestream_put_byte(dst, val);
32 
+}
33 
+
34 
+void ff_amf_write_number(uint8_t **dst, double val)
35 
+{
36 
+    bytestream_put_byte(dst, AMF_DATA_TYPE_NUMBER);
37 
+    bytestream_put_be64(dst, av_dbl2int(val));
38 
+}
39 
+
40 
+void ff_amf_write_string(uint8_t **dst, const char *str)
41 
+{
42 
+    bytestream_put_byte(dst, AMF_DATA_TYPE_STRING);
43 
+    bytestream_put_be16(dst, strlen(str));
44 
+    bytestream_put_buffer(dst, str, strlen(str));
45 
+}
46 
+
47 
+void ff_amf_write_null(uint8_t **dst)
48 
+{
49 
+    bytestream_put_byte(dst, AMF_DATA_TYPE_NULL);
50 
+}
51 
+
52 
+void ff_amf_write_object_start(uint8_t **dst)
53 
+{
54 
+    bytestream_put_byte(dst, AMF_DATA_TYPE_OBJECT);
55 
+}
56 
+
57 
+void ff_amf_write_field_name(uint8_t **dst, const char *str)
58 
+{
59 
+    bytestream_put_be16(dst, strlen(str));
60 
+    bytestream_put_buffer(dst, str, strlen(str));
61 
+}
62 
+
63 
+void ff_amf_write_object_end(uint8_t **dst)
64 
+{
65 
+    /* first two bytes are field name length = 0,
66 
+     * AMF object should end with it and end marker
67 
+     */
68 
+    bytestream_put_be24(dst, AMF_DATA_TYPE_OBJECT_END);
69 
+}
70 
+
71 
+int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p,
72 
+                        int chunk_size, RTMPPacket *prev_pkt)
73 
+{
74 
+    uint8_t hdr, t, buf[16];
75 
+    int channel_id, timestamp, data_size, offset = 0;
76 
+    uint32_t extra = 0;
77 
+    uint8_t type;
78 
+
79 
+    if (url_read(h, &hdr, 1) != 1)
80 
+        return AVERROR(EIO);
81 
+    channel_id = hdr & 0x3F;
82 
+
83 
+    data_size = prev_pkt[channel_id].data_size;
84 
+    type      = prev_pkt[channel_id].type;
85 
+    extra     = prev_pkt[channel_id].extra;
86 
+
87 
+    hdr >>= 6;
88 
+    if (hdr == RTMP_PS_ONEBYTE) {
89 
+        //todo
90 
+        return -1;
91 
+    } else {
92 
+        if (url_read_complete(h, buf, 3) != 3)
93 
+            return AVERROR(EIO);
94 
+        timestamp = AV_RB24(buf);
95 
+        if (hdr != RTMP_PS_FOURBYTES) {
96 
+            if (url_read_complete(h, buf, 3) != 3)
97 
+                return AVERROR(EIO);
98 
+            data_size = AV_RB24(buf);
99 
+            if (url_read_complete(h, &type, 1) != 1)
100 
+                return AVERROR(EIO);
101 
+            if (hdr == RTMP_PS_TWELVEBYTES) {
102 
+                if (url_read_complete(h, buf, 4) != 4)
103 
+                    return AVERROR(EIO);
104 
+                extra = AV_RL32(buf);
105 
+            }
106 
+        }
107 
+    }
108 
+    if (ff_rtmp_packet_create(p, channel_id, type, timestamp, data_size))
109 
+        return -1;
110 
+    p->extra = extra;
111 
+    // save history
112 
+    prev_pkt[channel_id].channel_id = channel_id;
113 
+    prev_pkt[channel_id].type       = type;
114 
+    prev_pkt[channel_id].data_size  = data_size;
115 
+    prev_pkt[channel_id].timestamp  = timestamp;
116 
+    prev_pkt[channel_id].extra      = extra;
117 
+    while (data_size > 0) {
118 
+        int toread = FFMIN(data_size, chunk_size);
119 
+        if (url_read_complete(h, p->data + offset, toread) != toread) {
120 
+            ff_rtmp_packet_destroy(p);
121 
+            return AVERROR(EIO);
122 
+        }
123 
+        data_size -= chunk_size;
124 
+        offset    += chunk_size;
125 
+        if (data_size > 0) {
126 
+            url_read_complete(h, &t, 1); //marker
127 
+            if (t != (0xC0 + channel_id))
128 
+                return -1;
129 
+        }
130 
+    }
131 
+    return 0;
132 
+}
133 
+
134 
+int ff_rtmp_packet_write(URLContext *h, RTMPPacket *pkt,
135 
+                         int chunk_size, RTMPPacket *prev_pkt)
136 
+{
137 
+    uint8_t pkt_hdr[16], *p = pkt_hdr;
138 
+    int mode = RTMP_PS_TWELVEBYTES;
139 
+    int off = 0;
140 
+
141 
+    //TODO: header compression
142 
+    bytestream_put_byte(&p, pkt->channel_id | (mode << 6));
143 
+    if (mode != RTMP_PS_ONEBYTE) {
144 
+        bytestream_put_be24(&p, pkt->timestamp);
145 
+        if (mode != RTMP_PS_FOURBYTES) {
146 
+            bytestream_put_be24(&p, pkt->data_size);
147 
+            bytestream_put_byte(&p, pkt->type);
148 
+            if (mode == RTMP_PS_TWELVEBYTES)
149 
+                bytestream_put_le32(&p, pkt->extra);
150 
+        }
151 
+    }
152 
+    url_write(h, pkt_hdr, p-pkt_hdr);
153 
+    while (off < pkt->data_size) {
154 
+        int towrite = FFMIN(chunk_size, pkt->data_size - off);
155 
+        url_write(h, pkt->data + off, towrite);
156 
+        off += towrite;
157 
+        if (off < pkt->data_size) {
158 
+            uint8_t marker = 0xC0 | pkt->channel_id;
159 
+            url_write(h, &marker, 1);
160 
+        }
161 
+    }
162 
+    return 0;
163 
+}
164 
+
165 
+int ff_rtmp_packet_create(RTMPPacket *pkt, int channel_id, RTMPPacketType type,
166 
+                          int timestamp, int size)
167 
+{
168 
+    pkt->data = av_malloc(size);
169 
+    if (!pkt->data)
170 
+        return AVERROR(ENOMEM);
171 
+    pkt->data_size  = size;
172 
+    pkt->channel_id = channel_id;
173 
+    pkt->type       = type;
174 
+    pkt->timestamp  = timestamp;
175 
+    pkt->extra      = 0;
176 
+
177 
+    return 0;
178 
+}
179 
+
180 
+void ff_rtmp_packet_destroy(RTMPPacket *pkt)
181 
+{
182 
+    if (!pkt)
183 
+        return;
184 
+    av_freep(&pkt->data);
185 
+    pkt->data_size = 0;
186 
+}
187 
+
188 
+int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end)
189 
+{
190 
+    const uint8_t *base = data;
191 
+
192 
+    if (data >= data_end)
193 
+        return -1;
194 
+    switch (*data++) {
195 
+    case AMF_DATA_TYPE_NUMBER:      return 9;
196 
+    case AMF_DATA_TYPE_BOOL:        return 2;
197 
+    case AMF_DATA_TYPE_STRING:      return 3 + AV_RB16(data);
198 
+    case AMF_DATA_TYPE_LONG_STRING: return 5 + AV_RB32(data);
199 
+    case AMF_DATA_TYPE_NULL:        return 1;
200 
+    case AMF_DATA_TYPE_ARRAY:
201 
+        data += 4;
202 
+    case AMF_DATA_TYPE_OBJECT:
203 
+        for (;;) {
204 
+            int size = bytestream_get_be16(&data);
205 
+            int t;
206 
+            if (!size) {
207 
+                data++;
208 
+                break;
209 
+            }
210 
+            if (data + size >= data_end || data + size < data)
211 
+                return -1;
212 
+            data += size;
213 
+            t = ff_amf_tag_size(data, data_end);
214 
+            if (t < 0 || data + t >= data_end)
215 
+                return -1;
216 
+            data += t;
217 
+        }
218 
+        return data - base;
219 
+    case AMF_DATA_TYPE_OBJECT_END:  return 1;
220 
+    default:                        return -1;
221 
+    }
222 
+}
223 
+
224 
+int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end,
225 
+                           const uint8_t *name, uint8_t *dst, int dst_size)
226 
+{
227 
+    int namelen = strlen(name);
228 
+    int len;
229 
+
230 
+    if (data_end - data < 3)
231 
+        return -1;
232 
+    if (*data++ != AMF_DATA_TYPE_OBJECT)
233 
+        return -1;
234 
+    for (;;) {
235 
+        int size = bytestream_get_be16(&data);
236 
+        if (!size)
237 
+            break;
238 
+        if (data + size >= data_end || data + size < data)
239 
+            return -1;
240 
+        data += size;
241 
+        if (size == namelen && !memcmp(data-size, name, namelen)) {
242 
+            switch (*data++) {
243 
+            case AMF_DATA_TYPE_NUMBER:
244 
+                snprintf(dst, dst_size, "%g", av_int2dbl(AV_RB64(data)));
245 
+                break;
246 
+            case AMF_DATA_TYPE_BOOL:
247 
+                snprintf(dst, dst_size, "%s", *data ? "true" : "false");
248 
+                break;
249 
+            case AMF_DATA_TYPE_STRING:
250 
+                len = bytestream_get_be16(&data);
251 
+                av_strlcpy(dst, data, FFMIN(len+1, dst_size));
252 
+                break;
253 
+            default:
254 
+                return -1;
255 
+            }
256 
+            return 0;
257 
+        }
258 
+        len = ff_amf_tag_size(data, data_end);
259 
+        if (len < 0 || data + len >= data_end || data + len < data)
260 
+            return -1;
261 
+        data += len;
262 
+    }
263 
+    return -1;
264 
+}
libavformat/rtmppkt.h
History View file @ 9fd6b84
0 265 
new file mode 100644
... ... 
@@ -0,0 +1,212 @@
0 
+/*
1 
+ * RTMP packet utilities
2 
+ * Copyright (c) 2009 Kostya Shishkov
3 
+ *
4 
+ * This file is part of FFmpeg.
5 
+ *
6 
+ * FFmpeg is free software; you can redistribute it and/or
7 
+ * modify it under the terms of the GNU Lesser General Public
8 
+ * License as published by the Free Software Foundation; either
9 
+ * version 2.1 of the License, or (at your option) any later version.
10 
+ *
11 
+ * FFmpeg is distributed in the hope that it will be useful,
12 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 
+ * Lesser General Public License for more details.
15 
+ *
16 
+ * You should have received a copy of the GNU Lesser General Public
17 
+ * License along with FFmpeg; if not, write to the Free Software
18 
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 
+ */
20 
+
21 
+#ifndef AVFORMAT_RTMPPKT_H
22 
+#define AVFORMAT_RTMPPKT_H
23 
+
24 
+#include "avformat.h"
25 
+
26 
+/** maximum possible number of different RTMP channels */
27 
+#define RTMP_CHANNELS 64
28 
+
29 
+/**
30 
+ * channels used to for RTMP packets with different purposes (i.e. data, network
31 
+ * control, remote procedure calls, etc.)
32 
+ */
33 
+enum RTMPChannel {
34 
+    RTMP_NETWORK_CHANNEL = 2,   ///< channel for network-related messages (bandwidth report, ping, etc)
35 
+    RTMP_SYSTEM_CHANNEL,        ///< channel for sending server control messages
36 
+    RTMP_VIDEO_CHANNEL = 8,     ///< channel for video data
37 
+    RTMP_AUDIO_CHANNEL,         ///< channel for audio data
38 
+};
39 
+
40 
+/**
41 
+ * known RTMP packet types
42 
+ */
43 
+typedef enum RTMPPacketType {
44 
+    RTMP_PT_CHUNK_SIZE   =  1,  ///< chunk size change
45 
+    RTMP_PT_BYTES_READ   =  3,  ///< number of bytes read
46 
+    RTMP_PT_PING,               ///< ping
47 
+    RTMP_PT_SERVER_BW,          ///< server bandwidth
48 
+    RTMP_PT_CLIENT_BW,          ///< client bandwidth
49 
+    RTMP_PT_AUDIO        =  8,  ///< audio packet
50 
+    RTMP_PT_VIDEO,              ///< video packet
51 
+    RTMP_PT_FLEX_STREAM  = 15,  ///< Flex shared stream
52 
+    RTMP_PT_FLEX_OBJECT,        ///< Flex shared object
53 
+    RTMP_PT_FLEX_MESSAGE,       ///< Flex shared message
54 
+    RTMP_PT_NOTIFY,             ///< some notification
55 
+    RTMP_PT_SHARED_OBJ,         ///< shared object
56 
+    RTMP_PT_INVOKE,             ///< invoke some stream action
57 
+    RTMP_PT_METADATA     = 22,  ///< FLV metadata
58 
+} RTMPPacketType;
59 
+
60 
+/**
61 
+ * possible RTMP packet header sizes
62 
+ */
63 
+enum RTMPPacketSize {
64 
+    RTMP_PS_TWELVEBYTES = 0, ///< packet has 12-byte header
65 
+    RTMP_PS_EIGHTBYTES,      ///< packet has 8-byte header
66 
+    RTMP_PS_FOURBYTES,       ///< packet has 4-byte header
67 
+    RTMP_PS_ONEBYTE          ///< packet is really a next chunk of a packet
68 
+};
69 
+
70 
+/**
71 
+ * structure for holding RTMP packets
72 
+ */
73 
+typedef struct RTMPPacket {
74 
+    uint8_t        channel_id; ///< RTMP channel ID (nothing to do with audio/video channels though)
75 
+    RTMPPacketType type;       ///< packet payload type
76 
+    uint32_t       timestamp;  ///< packet full timestamp or timestamp increment to the previous one in milliseconds (latter only for media packets)
77 
+    uint32_t       extra;      ///< probably an additional channel ID used during streaming data
78 
+    uint8_t        *data;      ///< packet payload
79 
+    int            data_size;  ///< packet payload size
80 
+} RTMPPacket;
81 
+
82 
+/**
83 
+ * Creates new RTMP packet with given attributes.
84 
+ *
85 
+ * @param pkt        packet
86 
+ * @param channel_id packet channel ID
87 
+ * @param type       packet type
88 
+ * @param timestamp  packet timestamp
89 
+ * @param size       packet size
90 
+ * @return zero on success, negative value otherwise
91 
+ */
92 
+int ff_rtmp_packet_create(RTMPPacket *pkt, int channel_id, RTMPPacketType type,
93 
+                          int timestamp, int size);
94 
+
95 
+/**
96 
+ * Frees RTMP packet.
97 
+ *
98 
+ * @param pkt packet
99 
+ */
100 
+void ff_rtmp_packet_destroy(RTMPPacket *pkt);
101 
+
102 
+/**
103 
+ * Reads RTMP packet sent by the server.
104 
+ *
105 
+ * @param h          reader context
106 
+ * @param p          packet
107 
+ * @param chunk_size current chunk size
108 
+ * @param prev_pkt   previously read packet headers for all channels
109 
+ *                   (may be needed for restoring incomplete packet header)
110 
+ * @return zero on success, negative value otherwise
111 
+ */
112 
+int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p,
113 
+                        int chunk_size, RTMPPacket *prev_pkt);
114 
+
115 
+/**
116 
+ * Sends RTMP packet to the server.
117 
+ *
118 
+ * @param h          reader context
119 
+ * @param p          packet to send
120 
+ * @param chunk_size current chunk size
121 
+ * @param prev_pkt   previously sent packet headers for all channels
122 
+ *                   (may be used for packet header compressing)
123 
+ * @return zero on success, negative value otherwise
124 
+ */
125 
+int ff_rtmp_packet_write(URLContext *h, RTMPPacket *p,
126 
+                         int chunk_size, RTMPPacket *prev_pkt);
127 
+
128 
+/**
129 
+ * @defgroup amffuncs functions used to work with AMF format (which is also used in .flv)
130 
+ * @see amf_* funcs in libavformat/flvdec.c
131 
+ * @{
132 
+ */
133 
+
134 
+/**
135 
+ * Calculates number of bytes taken by first AMF entry in data.
136 
+ *
137 
+ * @param data input data
138 
+ * @param data_end input buffer end
139 
+ * @return number of bytes used by first AMF entry
140 
+ */
141 
+int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end);
142 
+
143 
+/**
144 
+ * Retrieves value of given AMF object field in string form.
145 
+ *
146 
+ * @param data     AMF object data
147 
+ * @param data_end input buffer end
148 
+ * @param name     name of field to retrieve
149 
+ * @param dst      buffer for storing result
150 
+ * @param dst_size output buffer size
151 
+ * @return 0 if search and retrieval succeeded, negative value otherwise
152 
+ */
153 
+int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end,
154 
+                           const uint8_t *name, uint8_t *dst, int dst_size);
155 
+
156 
+/**
157 
+ * Writes boolean value in AMF format to buffer.
158 
+ *
159 
+ * @param dst pointer to the input buffer (will be modified)
160 
+ * @param val value to write
161 
+ */
162 
+void ff_amf_write_bool(uint8_t **dst, int val);
163 
+
164 
+/**
165 
+ * Writes number in AMF format to buffer.
166 
+ *
167 
+ * @param dst pointer to the input buffer (will be modified)
168 
+ * @param num value to write
169 
+ */
170 
+void ff_amf_write_number(uint8_t **dst, double num);
171 
+
172 
+/**
173 
+ * Writes string in AMF format to buffer.
174 
+ *
175 
+ * @param dst pointer to the input buffer (will be modified)
176 
+ * @param str string to write
177 
+ */
178 
+void ff_amf_write_string(uint8_t **dst, const char *str);
179 
+
180 
+/**
181 
+ * Writes AMF NULL value to buffer.
182 
+ *
183 
+ * @param dst pointer to the input buffer (will be modified)
184 
+ */
185 
+void ff_amf_write_null(uint8_t **dst);
186 
+
187 
+/**
188 
+ * Writes marker for AMF object to buffer.
189 
+ *
190 
+ * @param dst pointer to the input buffer (will be modified)
191 
+ */
192 
+void ff_amf_write_object_start(uint8_t **dst);
193 
+
194 
+/**
195 
+ * Writes string used as field name in AMF object to buffer.
196 
+ *
197 
+ * @param dst pointer to the input buffer (will be modified)
198 
+ * @param str string to write
199 
+ */
200 
+void ff_amf_write_field_name(uint8_t **dst, const char *str);
201 
+
202 
+/**
203 
+ * Writes marker for end of AMF object to buffer.
204 
+ *
205 
+ * @param dst pointer to the input buffer (will be modified)
206 
+ */
207 
+void ff_amf_write_object_end(uint8_t **dst);
208 
+
209 
+/** @} */ // AMF funcs
210 
+
211 
+#endif /* AVFORMAT_RTMPPKT_H */
libavformat/rtmpproto.c
History View file @ 9fd6b84
0 212 
new file mode 100644
... ... 
@@ -0,0 +1,695 @@
0 
+/*
1 
+ * RTMP network protocol
2 
+ * Copyright (c) 2009 Kostya Shishkov
3 
+ *
4 
+ * This file is part of FFmpeg.
5 
+ *
6 
+ * FFmpeg is free software; you can redistribute it and/or
7 
+ * modify it under the terms of the GNU Lesser General Public
8 
+ * License as published by the Free Software Foundation; either
9 
+ * version 2.1 of the License, or (at your option) any later version.
10 
+ *
11 
+ * FFmpeg is distributed in the hope that it will be useful,
12 
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 
+ * Lesser General Public License for more details.
15 
+ *
16 
+ * You should have received a copy of the GNU Lesser General Public
17 
+ * License along with FFmpeg; if not, write to the Free Software
18 
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 
+ */
20 
+
21 
+/**
22 
+ * @file libavformat/rtmpproto.c
23 
+ * RTMP protocol
24 
+ */
25 
+
26 
+#include "libavcodec/bytestream.h"
27 
+#include "libavutil/avstring.h"
28 
+#include "libavutil/lfg.h"
29 
+#include "libavutil/sha.h"
30 
+#include "avformat.h"
31 
+
32 
+#include "network.h"
33 
+
34 
+#include "flv.h"
35 
+#include "rtmp.h"
36 
+#include "rtmppkt.h"
37 
+
38 
+/* we can't use av_log() with URLContext yet... */
39 
+#if LIBAVFORMAT_VERSION_MAJOR < 53
40 
+#define LOG_CONTEXT NULL
41 
+#else
42 
+#define LOG_CONTEXT s
43 
+#endif
44 
+
45 
+/** RTMP protocol handler state */
46 
+typedef enum {
47 
+    STATE_START,      ///< client has not done anything yet
48 
+    STATE_HANDSHAKED, ///< client has performed handshake
49 
+    STATE_CONNECTING, ///< client connected to server successfully
50 
+    STATE_READY,      ///< client has sent all needed commands and waits for server reply
51 
+    STATE_PLAYING,    ///< client has started receiving multimedia data from server
52 
+} ClientState;
53 
+
54 
+/** protocol handler context */
55 
+typedef struct RTMPContext {
56 
+    URLContext*   stream;                     ///< TCP stream used in interactions with RTMP server
57 
+    RTMPPacket    prev_pkt[2][RTMP_CHANNELS]; ///< packet history used when reading and sending packets
58 
+    int           chunk_size;                 ///< size of the chunks RTMP packets are divided into
59 
+    char          playpath[256];              ///< path to filename to play (with possible "mp4:" prefix)
60 
+    ClientState   state;                      ///< current state
61 
+    int           main_channel_id;            ///< an additional channel ID which is used for some invocations
62 
+    uint8_t*      flv_data;                   ///< buffer with data for demuxer
63 
+    int           flv_size;                   ///< current buffer size
64 
+    int           flv_off;                    ///< number of bytes read from current buffer
65 
+    uint32_t      video_ts;                   ///< current video timestamp in milliseconds
66 
+    uint32_t      audio_ts;                   ///< current audio timestamp in milliseconds
67 
+} RTMPContext;
68 
+
69 
+#define PLAYER_KEY_OPEN_PART_LEN 30   ///< length of partial key used for first client digest signing
70 
+/** Client key used for digest signing */
71 
+static const uint8_t rtmp_player_key[] = {
72 
+    'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
73 
+    'F', 'l', 'a', 's', 'h', ' ', 'P', 'l', 'a', 'y', 'e', 'r', ' ', '0', '0', '1',
74 
+
75 
+    0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
76 
+    0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
77 
+    0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
78 
+};
79 
+
80 
+#define SERVER_KEY_OPEN_PART_LEN 36   ///< length of partial key used for first server digest signing
81 
+/** Key used for RTMP server digest signing */
82 
+static const uint8_t rtmp_server_key[] = {
83 
+    'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
84 
+    'F', 'l', 'a', 's', 'h', ' ', 'M', 'e', 'd', 'i', 'a', ' ',
85 
+    'S', 'e', 'r', 'v', 'e', 'r', ' ', '0', '0', '1',
86 
+
87 
+    0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
88 
+    0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
89 
+    0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
90 
+};
91 
+
92 
+/**
93 
+ * Generates 'connect' call and sends it to the server.
94 
+ */
95 
+static void gen_connect(URLContext *s, RTMPContext *rt, const char *proto,
96 
+                        const char *host, int port, const char *app)
97 
+{
98 
+    RTMPPacket pkt;
99 
+    uint8_t ver[32], *p;
100 
+    char tcurl[512];
101 
+
102 
+    ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0, 4096);
103 
+    p = pkt.data;
104 
+
105 
+    snprintf(tcurl, sizeof(tcurl), "%s://%s:%d/%s", proto, host, port, app);
106 
+    ff_amf_write_string(&p, "connect");
107 
+    ff_amf_write_number(&p, 1.0);
108 
+    ff_amf_write_object_start(&p);
109 
+    ff_amf_write_field_name(&p, "app");
110 
+    ff_amf_write_string(&p, app);
111 
+
112 
+    snprintf(ver, sizeof(ver), "%s %d,%d,%d,%d", RTMP_CLIENT_PLATFORM, RTMP_CLIENT_VER1,
113 
+             RTMP_CLIENT_VER2, RTMP_CLIENT_VER3, RTMP_CLIENT_VER4);
114 
+    ff_amf_write_field_name(&p, "flashVer");
115 
+    ff_amf_write_string(&p, ver);
116 
+    ff_amf_write_field_name(&p, "tcUrl");
117 
+    ff_amf_write_string(&p, tcurl);
118 
+    ff_amf_write_field_name(&p, "fpad");
119 
+    ff_amf_write_bool(&p, 0);
120 
+    ff_amf_write_field_name(&p, "capabilities");
121 
+    ff_amf_write_number(&p, 15.0);
122 
+    ff_amf_write_field_name(&p, "audioCodecs");
123 
+    ff_amf_write_number(&p, 1639.0);
124 
+    ff_amf_write_field_name(&p, "videoCodecs");
125 
+    ff_amf_write_number(&p, 252.0);
126 
+    ff_amf_write_field_name(&p, "videoFunction");
127 
+    ff_amf_write_number(&p, 1.0);
128 
+    ff_amf_write_object_end(&p);
129 
+
130 
+    pkt.data_size = p - pkt.data;
131 
+
132 
+    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
133 
+}
134 
+
135 
+/**
136 
+ * Generates 'createStream' call and sends it to the server. It should make
137 
+ * the server allocate some channel for media streams.
138 
+ */
139 
+static void gen_create_stream(URLContext *s, RTMPContext *rt)
140 
+{
141 
+    RTMPPacket pkt;
142 
+    uint8_t *p;
143 
+
144 
+    av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Creating stream...\n");
145 
+    ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0, 25);
146 
+
147 
+    p = pkt.data;
148 
+    ff_amf_write_string(&p, "createStream");
149 
+    ff_amf_write_number(&p, 3.0);
150 
+    ff_amf_write_null(&p);
151 
+
152 
+    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
153 
+    ff_rtmp_packet_destroy(&pkt);
154 
+}
155 
+
156 
+/**
157 
+ * Generates 'play' call and sends it to the server, then pings the server
158 
+ * to start actual playing.
159 
+ */
160 
+static void gen_play(URLContext *s, RTMPContext *rt)
161 
+{
162 
+    RTMPPacket pkt;
163 
+    uint8_t *p;
164 
+
165 
+    av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
166 
+    ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0,
167 
+                          29 + strlen(rt->playpath));
168 
+    pkt.extra = rt->main_channel_id;
169 
+
170 
+    p = pkt.data;
171 
+    ff_amf_write_string(&p, "play");
172 
+    ff_amf_write_number(&p, 0.0);
173 
+    ff_amf_write_null(&p);
174 
+    ff_amf_write_string(&p, rt->playpath);
175 
+    ff_amf_write_number(&p, 0.0);
176 
+
177 
+    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
178 
+    ff_rtmp_packet_destroy(&pkt);
179 
+
180 
+    // set client buffer time disguised in ping packet
181 
+    ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING, 1, 10);
182 
+
183 
+    p = pkt.data;
184 
+    bytestream_put_be16(&p, 3);
185 
+    bytestream_put_be32(&p, 1);
186 
+    bytestream_put_be32(&p, 256); //TODO: what is a good value here?
187 
+
188 
+    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
189 
+    ff_rtmp_packet_destroy(&pkt);
190 
+}
191 
+
192 
+/**
193 
+ * Generates ping reply and sends it to the server.
194 
+ */
195 
+static void gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
196 
+{
197 
+    RTMPPacket pkt;
198 
+    uint8_t *p;
199 
+
200 
+    ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING, ppkt->timestamp + 1, 6);
201 
+    p = pkt.data;
202 
+    bytestream_put_be16(&p, 7);
203 
+    bytestream_put_be32(&p, AV_RB32(ppkt->data+2) + 1);
204 
+    ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
205 
+    ff_rtmp_packet_destroy(&pkt);
206 
+}
207 
+
208 
+//TODO: Move HMAC code somewhere. Eventually.
209 
+#define HMAC_IPAD_VAL 0x36
210 
+#define HMAC_OPAD_VAL 0x5C
211 
+
212 
+/**
213 
+ * Calculates HMAC-SHA2 digest for RTMP handshake packets.
214 
+ *
215 
+ * @param src    input buffer
216 
+ * @param len    input buffer length (should be 1536)
217 
+ * @param gap    offset in buffer where 32 bytes should not be taken into account
218 
+ *               when calculating digest (since it will be used to store that digest)
219 
+ * @param key    digest key
220 
+ * @param keylen digest key length
221 
+ * @param dst    buffer where calculated digest will be stored (32 bytes)
222 
+ */
223 
+static void rtmp_calc_digest(const uint8_t *src, int len, int gap,
224 
+                             const uint8_t *key, int keylen, uint8_t *dst)
225 
+{
226 
+    struct AVSHA *sha;
227 
+    uint8_t hmac_buf[64+32] = {0};
228 
+    int i;
229 
+
230 
+    sha = av_mallocz(av_sha_size);
231 
+
232 
+    if (keylen < 64) {
233 
+        memcpy(hmac_buf, key, keylen);
234 
+    } else {
235 
+        av_sha_init(sha, 256);
236 
+        av_sha_update(sha,key, keylen);
237 
+        av_sha_final(sha, hmac_buf);
238 
+    }
239 
+    for (i = 0; i < 64; i++)
240 
+        hmac_buf[i] ^= HMAC_IPAD_VAL;
241 
+
242 
+    av_sha_init(sha, 256);
243 
+    av_sha_update(sha, hmac_buf, 64);
244 
+    if (gap <= 0) {
245 
+        av_sha_update(sha, src, len);
246 
+    } else { //skip 32 bytes used for storing digest
247 
+        av_sha_update(sha, src, gap);
248 
+        av_sha_update(sha, src + gap + 32, len - gap - 32);
249 
+    }
250 
+    av_sha_final(sha, hmac_buf + 64);
251 
+
252 
+    for (i = 0; i < 64; i++)
253 
+        hmac_buf[i] ^= HMAC_IPAD_VAL ^ HMAC_OPAD_VAL; //reuse XORed key for opad
254 
+    av_sha_init(sha, 256);
255 
+    av_sha_update(sha, hmac_buf, 64+32);
256 
+    av_sha_final(sha, dst);
257 
+
258 
+    av_free(sha);
259 
+}
260 
+
261 
+/**
262 
+ * Puts HMAC-SHA2 digest of packet data (except for the bytes where this digest
263 
+ * will be stored) into that packet.
264 
+ *
265 
+ * @param buf handshake data (1536 bytes)
266 
+ * @return offset to the digest inside input data
267 
+ */
268 
+static int rtmp_handshake_imprint_with_digest(uint8_t *buf)
269 
+{
270 
+    int i, digest_pos = 0;
271 
+
272 
+    for (i = 8; i < 12; i++)
273 
+        digest_pos += buf[i];
274 
+    digest_pos = (digest_pos % 728) + 12;
275 
+
276 
+    rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
277 
+                     rtmp_player_key, PLAYER_KEY_OPEN_PART_LEN,
278 
+                     buf + digest_pos);
279 
+    return digest_pos;
280 
+}
281 
+
282 
+/**
283 
+ * Verifies that the received server response has the expected digest value.
284 
+ *
285 
+ * @param buf handshake data received from the server (1536 bytes)
286 
+ * @param off position to search digest offset from
287 
+ * @return 0 if digest is valid, digest position otherwise
288 
+ */
289 
+static int rtmp_validate_digest(uint8_t *buf, int off)
290 
+{
291 
+    int i, digest_pos = 0;
292 
+    uint8_t digest[32];
293 
+
294 
+    for (i = 0; i < 4; i++)
295 
+        digest_pos += buf[i + off];
296 
+    digest_pos = (digest_pos % 728) + off + 4;
297 
+
298 
+    rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
299 
+                     rtmp_server_key, SERVER_KEY_OPEN_PART_LEN,
300 
+                     digest);
301 
+    if (!memcmp(digest, buf + digest_pos, 32))
302 
+        return digest_pos;
303 
+    return 0;
304 
+}
305 
+
306 
+/**
307 
+ * Performs handshake with the server by means of exchanging pseudorandom data
308 
+ * signed with HMAC-SHA2 digest.
309 
+ *
310 
+ * @return 0 if handshake succeeds, negative value otherwise
311 
+ */
312 
+static int rtmp_handshake(URLContext *s, RTMPContext *rt)
313 
+{
314 
+    AVLFG rnd;
315 
+    uint8_t tosend    [RTMP_HANDSHAKE_PACKET_SIZE+1] = {
316 
+        3,                // unencrypted data
317 
+        0, 0, 0, 0,       // client uptime
318 
+        RTMP_CLIENT_VER1,
319 
+        RTMP_CLIENT_VER2,
320 
+        RTMP_CLIENT_VER3,
321 
+        RTMP_CLIENT_VER4,
322 
+    };
323 
+    uint8_t clientdata[RTMP_HANDSHAKE_PACKET_SIZE];
324 
+    uint8_t serverdata[RTMP_HANDSHAKE_PACKET_SIZE+1];
325 
+    int i;
326 
+    int server_pos, client_pos;
327 
+    uint8_t digest[32];
328 
+
329 
+    av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Handshaking...\n");
330 
+
331 
+    av_lfg_init(&rnd, 0xDEADC0DE);
332 
+    // generate handshake packet - 1536 bytes of pseudorandom data
333 
+    for (i = 9; i <= RTMP_HANDSHAKE_PACKET_SIZE; i++)
334 
+        tosend[i] = av_lfg_get(&rnd) >> 24;
335 
+    client_pos = rtmp_handshake_imprint_with_digest(tosend + 1);
336 
+
337 
+    url_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE + 1);
338 
+    i = url_read_complete(rt->stream, serverdata, RTMP_HANDSHAKE_PACKET_SIZE + 1);
339 
+    if (i != RTMP_HANDSHAKE_PACKET_SIZE + 1) {
340 
+        av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
341 
+        return -1;
342 
+    }
343 
+    i = url_read_complete(rt->stream, clientdata, RTMP_HANDSHAKE_PACKET_SIZE);
344 
+    if (i != RTMP_HANDSHAKE_PACKET_SIZE) {
345 
+        av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
346 
+        return -1;
347 
+    }
348 
+
349 
+    av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
350 
+           serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
351 
+
352 
+    server_pos = rtmp_validate_digest(serverdata + 1, 772);
353 
+    if (!server_pos) {
354 
+        server_pos = rtmp_validate_digest(serverdata + 1, 8);
355 
+        if (!server_pos) {
356 
+            av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server response validating failed\n");
357 
+            return -1;
358 
+        }
359 
+    }
360 
+
361 
+    rtmp_calc_digest(tosend + 1 + client_pos, 32, 0,
362 
+                     rtmp_server_key, sizeof(rtmp_server_key),
363 
+                     digest);
364 
+    rtmp_calc_digest(clientdata, RTMP_HANDSHAKE_PACKET_SIZE-32, 0,
365 
+                     digest, 32,
366 
+                     digest);
367 
+    if (memcmp(digest, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
368 
+        av_log(LOG_CONTEXT, AV_LOG_ERROR, "Signature mismatch\n");
369 
+        return -1;
370 
+    }
371 
+
372 
+    for (i = 0; i < RTMP_HANDSHAKE_PACKET_SIZE; i++)
373 
+        tosend[i] = av_lfg_get(&rnd) >> 24;
374 
+    rtmp_calc_digest(serverdata + 1 + server_pos, 32, 0,
375 
+                     rtmp_player_key, sizeof(rtmp_player_key),
376 
+                     digest);
377 
+    rtmp_calc_digest(tosend,  RTMP_HANDSHAKE_PACKET_SIZE - 32, 0,
378 
+                     digest, 32,
379 
+                     tosend + RTMP_HANDSHAKE_PACKET_SIZE - 32);
380 
+
381 
+    // write reply back to the server
382 
+    url_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE);
383 
+    return 0;
384 
+}
385 
+
386 
+/**
387 
+ * Parses received packet and may perform some action depending on
388 
+ * the packet contents.
389 
+ * @return 0 for no errors, negative values for serious errors which prevent
390 
+ *         further communications, positive values for uncritical errors
391 
+ */
392 
+static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
393 
+{
394 
+    int i, t;
395 
+    const uint8_t *data_end = pkt->data + pkt->data_size;
396 
+
397 
+    switch (pkt->type) {
398 
+    case RTMP_PT_CHUNK_SIZE:
399 
+        if (pkt->data_size != 4) {
400 
+            av_log(LOG_CONTEXT, AV_LOG_ERROR,
401 
+                   "Chunk size change packet is not 4 bytes long (%d)\n", pkt->data_size);
402 
+            return -1;
403 
+        }
404 
+        rt->chunk_size = AV_RB32(pkt->data);
405 
+        if (rt->chunk_size <= 0) {
406 
+            av_log(LOG_CONTEXT, AV_LOG_ERROR, "Incorrect chunk size %d\n", rt->chunk_size);
407 
+            return -1;
408 
+        }
409 
+        av_log(LOG_CONTEXT, AV_LOG_DEBUG, "New chunk size = %d\n", rt->chunk_size);
410 
+        break;
411 
+    case RTMP_PT_PING:
412 
+        t = AV_RB16(pkt->data);
413 
+        if (t == 6)
414 
+            gen_pong(s, rt, pkt);
415 
+        break;
416 
+    case RTMP_PT_INVOKE:
417 
+        //TODO: check for the messages sent for wrong state?
418 
+        if (!memcmp(pkt->data, "\002\000\006_error", 9)) {
419 
+            uint8_t tmpstr[256];
420 
+
421 
+            if (!ff_amf_get_field_value(pkt->data + 9, data_end,
422 
+                                        "description", tmpstr, sizeof(tmpstr)))
423 
+                av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
424 
+            return -1;
425 
+        } else if (!memcmp(pkt->data, "\002\000\007_result", 10)) {
426 
+            switch (rt->state) {
427 
+            case STATE_HANDSHAKED:
428 
+                gen_create_stream(s, rt);
429 
+                rt->state = STATE_CONNECTING;
430 
+                break;
431 
+            case STATE_CONNECTING:
432 
+                //extract a number from the result
433 
+                if (pkt->data[10] || pkt->data[19] != 5 || pkt->data[20]) {
434 
+                    av_log(LOG_CONTEXT, AV_LOG_WARNING, "Unexpected reply on connect()\n");
435 
+                } else {
436 
+                    rt->main_channel_id = (int) av_int2dbl(AV_RB64(pkt->data + 21));
437 
+                }
438 
+                gen_play(s, rt);
439 
+                rt->state = STATE_READY;
440 
+                break;
441 
+            }
442 
+        } else if (!memcmp(pkt->data, "\002\000\010onStatus", 11)) {
443 
+            const uint8_t* ptr = pkt->data + 11;
444 
+            uint8_t tmpstr[256];
445 
+            int t;
446 
+
447 
+            for (i = 0; i < 2; i++) {
448 
+                t = ff_amf_tag_size(ptr, data_end);
449 
+                if (t < 0)
450 
+                    return 1;
451 
+                ptr += t;
452 
+            }
453 
+            t = ff_amf_get_field_value(ptr, data_end,
454 
+                                       "level", tmpstr, sizeof(tmpstr));
455 
+            if (!t && !strcmp(tmpstr, "error")) {
456 
+                if (!ff_amf_get_field_value(ptr, data_end,
457 
+                                            "description", tmpstr, sizeof(tmpstr)))
458 
+                    av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
459 
+                return -1;
460 
+            }
461 
+            t = ff_amf_get_field_value(ptr, data_end,
462 
+                                       "code", tmpstr, sizeof(tmpstr));
463 
+            if (!t && !strcmp(tmpstr, "NetStream.Play.Start")) {
464 
+                rt->state = STATE_PLAYING;
465 
+                return 0;
466 
+            }
467 
+        }
468 
+        break;
469 
+    }
470 
+    return 0;
471 
+}
472 
+
473 
+/**
474 
+ * Interacts with the server by receiving and sending RTMP packets until
475 
+ * there is some significant data (media data or expected status notification).
476 
+ *
477 
+ * @param s          reading context
478 
+ * @param for_header non-zero value tells function to work until it gets notification from the server that playing has been started, otherwise function will work until some media data is received (or an error happens)
479 
+ * @return 0 for successful operation, negative value in case of error
480 
+ */
481 
+static int get_packet(URLContext *s, int for_header)
482 
+{
483 
+    RTMPContext *rt = s->priv_data;
484 
+    int ret;
485 
+
486 
+    for(;;) {
487 
+        RTMPPacket rpkt;
488 
+        if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
489 
+                                       rt->chunk_size, rt->prev_pkt[0])) != 0) {
490 
+            if (ret > 0) {
491 
+                return AVERROR(EAGAIN);
492 
+            } else {
493 
+                return AVERROR(EIO);
494 
+            }
495 
+        }
496 
+
497 
+        ret = rtmp_parse_result(s, rt, &rpkt);
498 
+        if (ret < 0) {//serious error in current packet
499 
+            ff_rtmp_packet_destroy(&rpkt);
500 
+            return -1;
501 
+        }
502 
+        if (for_header && rt->state == STATE_PLAYING) {
503 
+            ff_rtmp_packet_destroy(&rpkt);
504 
+            return 0;
505 
+        }
506 
+        if (!rpkt.data_size) {
507 
+            ff_rtmp_packet_destroy(&rpkt);
508 
+            continue;
509 
+        }
510 
+        if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||
511 
+            rpkt.type == RTMP_PT_NOTIFY) {
512 
+            uint8_t *p;
513 
+            uint32_t ts = rpkt.timestamp;
514 
+
515 
+            if (rpkt.type == RTMP_PT_VIDEO) {
516 
+                rt->video_ts += rpkt.timestamp;
517 
+                ts = rt->video_ts;
518 
+            } else if (rpkt.type == RTMP_PT_AUDIO) {
519 
+                rt->audio_ts += rpkt.timestamp;
520 
+                ts = rt->audio_ts;
521 
+            }
522 
+            // generate packet header and put data into buffer for FLV demuxer
523 
+            rt->flv_off  = 0;
524 
+            rt->flv_size = rpkt.data_size + 15;
525 
+            rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);
526 
+            bytestream_put_byte(&p, rpkt.type);
527 
+            bytestream_put_be24(&p, rpkt.data_size);
528 
+            bytestream_put_be24(&p, ts);
529 
+            bytestream_put_byte(&p, ts >> 24);
530 
+            bytestream_put_be24(&p, 0);
531 
+            bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);
532 
+            bytestream_put_be32(&p, 0);
533 
+            ff_rtmp_packet_destroy(&rpkt);
534 
+            return 0;
535 
+        } else if (rpkt.type == RTMP_PT_METADATA) {
536 
+            // we got raw FLV data, make it available for FLV demuxer
537 
+            rt->flv_off  = 0;
538 
+            rt->flv_size = rpkt.data_size;
539 
+            rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
540 
+            memcpy(rt->flv_data, rpkt.data, rpkt.data_size);
541 
+            ff_rtmp_packet_destroy(&rpkt);
542 
+            return 0;
543 
+        }
544 
+        ff_rtmp_packet_destroy(&rpkt);
545 
+    }
546 
+    return 0;
547 
+}
548 
+
549 
+static int rtmp_close(URLContext *h)
550 
+{
551 
+    RTMPContext *rt = h->priv_data;
552 
+
553 
+    av_freep(&rt->flv_data);
554 
+    url_close(rt->stream);
555 
+    av_free(rt);
556 
+    return 0;
557 
+}
558 
+
559 
+/**
560 
+ * Opens RTMP connection and verifies that the stream can be played.
561 
+ *
562 
+ * URL syntax: rtmp://server[:port][/app][/playpath]
563 
+ *             where 'app' is first one or two directories in the path
564 
+ *             (e.g. /ondemand/, /flash/live/, etc.)
565 
+ *             and 'playpath' is a file name (the rest of the path,
566 
+ *             may be prefixed with "mp4:")
567 
+ */
568 
+static int rtmp_open(URLContext *s, const char *uri, int flags)
569 
+{
570 
+    RTMPContext *rt;
571 
+    char proto[8], hostname[256], path[1024], app[128], *fname;
572 
+    uint8_t buf[2048];
573 
+    int port, is_input;
574 
+    int ret;
575 
+
576 
+    is_input = !(flags & URL_WRONLY);
577 
+
578 
+    rt = av_mallocz(sizeof(RTMPContext));
579 
+    if (!rt)
580 
+        return AVERROR(ENOMEM);
581 
+    s->priv_data = rt;
582 
+
583 
+    url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname), &port,
584 
+              path, sizeof(path), s->filename);
585 
+
586 
+    if (port < 0)
587 
+        port = RTMP_DEFAULT_PORT;
588 
+    snprintf(buf, sizeof(buf), "tcp://%s:%d", hostname, port);
589 
+
590 
+    if (url_open(&rt->stream, buf, URL_RDWR) < 0)
591 
+        goto fail;
592 
+
593 
+    if (!is_input) {
594 
+        av_log(LOG_CONTEXT, AV_LOG_ERROR, "RTMP output is not supported yet.\n");
595 
+        goto fail;
596 
+    } else {
597 
+        rt->state = STATE_START;
598 
+        if (rtmp_handshake(s, rt))
599 
+            return -1;
600 
+
601 
+        rt->chunk_size = 128;
602 
+        rt->state = STATE_HANDSHAKED;
603 
+        //extract "app" part from path
604 
+        if (!strncmp(path, "/ondemand/", 10)) {
605 
+            fname = path + 10;
606 
+            memcpy(app, "ondemand", 9);
607 
+        } else {
608 
+            char *p = strchr(path + 1, '/');
609 
+            if (!p) {
610 
+                fname = path + 1;
611 
+                app[0] = '\0';
612 
+            } else {
613 
+                fname = strchr(p + 1, '/');
614 
+                if (!fname) {
615 
+                    fname = p + 1;
616 
+                    av_strlcpy(app, path + 1, p - path);
617 
+                } else {
618 
+                    fname++;
619 
+                    av_strlcpy(app, path + 1, fname - path - 1);
620 
+                }
621 
+            }
622 
+        }
623 
+        if (!strcmp(fname + strlen(fname) - 4, ".f4v") ||
624 
+            !strcmp(fname + strlen(fname) - 4, ".mp4")) {
625 
+            memcpy(rt->playpath, "mp4:", 5);
626 
+        } else {
627 
+            rt->playpath[0] = 0;
628 
+        }
629 
+        strncat(rt->playpath, fname, sizeof(rt->playpath) - 5);
630 
+
631 
+        av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
632 
+               proto, path, app, rt->playpath);
633 
+        gen_connect(s, rt, proto, hostname, port, app);
634 
+
635 
+        do {
636 
+            ret = get_packet(s, 1);
637 
+        } while (ret == EAGAIN);
638 
+        if (ret < 0)
639 
+            goto fail;
640 
+        // generate FLV header for demuxer
641 
+        rt->flv_size = 13;
642 
+        rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
643 
+        rt->flv_off  = 0;
644 
+        memcpy(rt->flv_data, "FLV\1\5\0\0\0\011\0\0\0\0", rt->flv_size);
645 
+    }
646 
+
647 
+    s->max_packet_size = url_get_max_packet_size(rt->stream);
648 
+    s->is_streamed     = 1;
649 
+    return 0;
650 
+
651 
+fail:
652 
+    rtmp_close(s);
653 
+    return AVERROR(EIO);
654 
+}
655 
+
656 
+static int rtmp_read(URLContext *s, uint8_t *buf, int size)
657 
+{
658 
+    RTMPContext *rt = s->priv_data;
659 
+    int orig_size = size;
660 
+    int ret;
661 
+
662 
+    while (size > 0) {
663 
+        int data_left = rt->flv_size - rt->flv_off;
664 
+
665 
+        if (data_left >= size) {
666 
+            memcpy(buf, rt->flv_data + rt->flv_off, size);
667 
+            rt->flv_off += size;
668 
+            return orig_size;
669 
+        }
670 
+        if (data_left > 0) {
671 
+            memcpy(buf, rt->flv_data + rt->flv_off, data_left);
672 
+            buf  += data_left;
673 
+            size -= data_left;
674 
+            rt->flv_off = rt->flv_size;
675 
+        }
676 
+        if ((ret = get_packet(s, 0)) < 0)
677 
+           return ret;
678 
+    }
679 
+    return orig_size;
680 
+}
681 
+
682 
+static int rtmp_write(URLContext *h, uint8_t *buf, int size)
683 
+{
684 
+    return 0;
685 
+}
686 
+
687 
+URLProtocol rtmp_protocol = {
688 
+    "rtmp",
689 
+    rtmp_open,
690 
+    rtmp_read,
691 
+    rtmp_write,
692 
+    NULL, /* seek */
693 
+    rtmp_close,
694 
+};