40073f33ad8b5293ad2788a4a6b0d0a747b08b55
[ffmpeg.git] / libavformat / librtmp.c
1 /*
2  * RTMP network protocol
3  * Copyright (c) 2010 Howard Chu
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 /**
23  * @file
24  * RTMP protocol based on http://rtmpdump.mplayerhq.hu/ librtmp
25  */
26
27 #include "libavutil/avstring.h"
28 #include "libavutil/mathematics.h"
29 #include "libavutil/opt.h"
30 #include "avformat.h"
31 #include "network.h"
32 #include "url.h"
33
34 #include <librtmp/rtmp.h>
35 #include <librtmp/log.h>
36
37 typedef struct LibRTMPContext {
38     const AVClass *class;
39     RTMP rtmp;
40     char *app;
41     char *conn;
42     char *subscribe;
43     char *playpath;
44     char *tcurl;
45     char *flashver;
46     char *swfurl;
47     char *swfverify;
48     char *pageurl;
49     char *client_buffer_time;
50     int live;
51     char *temp_filename;
52     int buffer_size;
53 } LibRTMPContext;
54
55 static void rtmp_log(int level, const char *fmt, va_list args)
56 {
57     switch (level) {
58     default:
59     case RTMP_LOGCRIT:    level = AV_LOG_FATAL;   break;
60     case RTMP_LOGERROR:   level = AV_LOG_ERROR;   break;
61     case RTMP_LOGWARNING: level = AV_LOG_WARNING; break;
62     case RTMP_LOGINFO:    level = AV_LOG_INFO;    break;
63     case RTMP_LOGDEBUG:   level = AV_LOG_VERBOSE; break;
64     case RTMP_LOGDEBUG2:  level = AV_LOG_DEBUG;   break;
65     }
66
67     av_vlog(NULL, level, fmt, args);
68     av_log(NULL, level, "\n");
69 }
70
71 static int rtmp_close(URLContext *s)
72 {
73     LibRTMPContext *ctx = s->priv_data;
74     RTMP *r = &ctx->rtmp;
75
76     RTMP_Close(r);
77     av_freep(&ctx->temp_filename);
78     return 0;
79 }
80
81 /**
82  * Open RTMP connection and verify that the stream can be played.
83  *
84  * URL syntax: rtmp://server[:port][/app][/playpath][ keyword=value]...
85  *             where 'app' is first one or two directories in the path
86  *             (e.g. /ondemand/, /flash/live/, etc.)
87  *             and 'playpath' is a file name (the rest of the path,
88  *             may be prefixed with "mp4:")
89  *
90  *             Additional RTMP library options may be appended as
91  *             space-separated key-value pairs.
92  */
93 static int rtmp_open(URLContext *s, const char *uri, int flags)
94 {
95     LibRTMPContext *ctx = s->priv_data;
96     RTMP *r = &ctx->rtmp;
97     int rc = 0, level;
98     char *filename = s->filename;
99     int len = strlen(s->filename) + 1;
100
101     switch (av_log_get_level()) {
102     default:
103     case AV_LOG_FATAL:   level = RTMP_LOGCRIT;    break;
104     case AV_LOG_ERROR:   level = RTMP_LOGERROR;   break;
105     case AV_LOG_WARNING: level = RTMP_LOGWARNING; break;
106     case AV_LOG_INFO:    level = RTMP_LOGINFO;    break;
107     case AV_LOG_VERBOSE: level = RTMP_LOGDEBUG;   break;
108     case AV_LOG_DEBUG:   level = RTMP_LOGDEBUG2;  break;
109     }
110     RTMP_LogSetLevel(level);
111     RTMP_LogSetCallback(rtmp_log);
112
113     if (ctx->app)      len += strlen(ctx->app)      + sizeof(" app=");
114     if (ctx->tcurl)    len += strlen(ctx->tcurl)    + sizeof(" tcUrl=");
115     if (ctx->pageurl)  len += strlen(ctx->pageurl)  + sizeof(" pageUrl=");
116     if (ctx->flashver) len += strlen(ctx->flashver) + sizeof(" flashver=");
117
118     if (ctx->conn) {
119         char *sep, *p = ctx->conn;
120         int options = 0;
121
122         while (p) {
123             options++;
124             p += strspn(p, " ");
125             if (!*p)
126                 break;
127             sep = strchr(p, ' ');
128             if (sep)
129                 p = sep + 1;
130             else
131                 break;
132         }
133         len += options * sizeof(" conn=");
134         len += strlen(ctx->conn);
135     }
136
137     if (ctx->playpath)
138         len += strlen(ctx->playpath) + sizeof(" playpath=");
139     if (ctx->live)
140         len += sizeof(" live=1");
141     if (ctx->subscribe)
142         len += strlen(ctx->subscribe) + sizeof(" subscribe=");
143
144     if (ctx->client_buffer_time)
145         len += strlen(ctx->client_buffer_time) + sizeof(" buffer=");
146
147     if (ctx->swfurl || ctx->swfverify) {
148         len += sizeof(" swfUrl=");
149
150         if (ctx->swfverify)
151             len += strlen(ctx->swfverify) + sizeof(" swfVfy=1");
152         else
153             len += strlen(ctx->swfurl);
154     }
155
156     if (!(ctx->temp_filename = filename = av_malloc(len)))
157         return AVERROR(ENOMEM);
158
159     av_strlcpy(filename, s->filename, len);
160     if (ctx->app) {
161         av_strlcat(filename, " app=", len);
162         av_strlcat(filename, ctx->app, len);
163     }
164     if (ctx->tcurl) {
165         av_strlcat(filename, " tcUrl=", len);
166         av_strlcat(filename, ctx->tcurl, len);
167     }
168     if (ctx->pageurl) {
169         av_strlcat(filename, " pageUrl=", len);
170         av_strlcat(filename, ctx->pageurl, len);
171     }
172     if (ctx->swfurl) {
173         av_strlcat(filename, " swfUrl=", len);
174         av_strlcat(filename, ctx->swfurl, len);
175     }
176     if (ctx->flashver) {
177         av_strlcat(filename, " flashVer=", len);
178         av_strlcat(filename, ctx->flashver, len);
179     }
180     if (ctx->conn) {
181         char *sep, *p = ctx->conn;
182         while (p) {
183             av_strlcat(filename, " conn=", len);
184             p += strspn(p, " ");
185             if (!*p)
186                 break;
187             sep = strchr(p, ' ');
188             if (sep)
189                 *sep = '\0';
190             av_strlcat(filename, p, len);
191
192             if (sep)
193                 p = sep + 1;
194         }
195     }
196     if (ctx->playpath) {
197         av_strlcat(filename, " playpath=", len);
198         av_strlcat(filename, ctx->playpath, len);
199     }
200     if (ctx->live)
201         av_strlcat(filename, " live=1", len);
202     if (ctx->subscribe) {
203         av_strlcat(filename, " subscribe=", len);
204         av_strlcat(filename, ctx->subscribe, len);
205     }
206     if (ctx->client_buffer_time) {
207         av_strlcat(filename, " buffer=", len);
208         av_strlcat(filename, ctx->client_buffer_time, len);
209     }
210     if (ctx->swfurl || ctx->swfverify) {
211         av_strlcat(filename, " swfUrl=", len);
212
213         if (ctx->swfverify) {
214             av_strlcat(filename, ctx->swfverify, len);
215             av_strlcat(filename, " swfVfy=1", len);
216         } else {
217             av_strlcat(filename, ctx->swfurl, len);
218         }
219     }
220
221     RTMP_Init(r);
222     if (!RTMP_SetupURL(r, filename)) {
223         rc = AVERROR_UNKNOWN;
224         goto fail;
225     }
226
227     if (flags & AVIO_FLAG_WRITE)
228         RTMP_EnableWrite(r);
229
230     if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0)) {
231         rc = AVERROR_UNKNOWN;
232         goto fail;
233     }
234
235     if (ctx->buffer_size >= 0 && (flags & AVIO_FLAG_WRITE)) {
236         int tmp = ctx->buffer_size;
237         setsockopt(r->m_sb.sb_socket, SOL_SOCKET, SO_SNDBUF, &tmp, sizeof(tmp));
238     }
239
240     s->is_streamed = 1;
241     return 0;
242 fail:
243     av_freep(&ctx->temp_filename);
244     if (rc)
245         RTMP_Close(r);
246
247     return rc;
248 }
249
250 static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
251 {
252     LibRTMPContext *ctx = s->priv_data;
253     RTMP *r = &ctx->rtmp;
254
255     return RTMP_Write(r, buf, size);
256 }
257
258 static int rtmp_read(URLContext *s, uint8_t *buf, int size)
259 {
260     LibRTMPContext *ctx = s->priv_data;
261     RTMP *r = &ctx->rtmp;
262
263     return RTMP_Read(r, buf, size);
264 }
265
266 static int rtmp_read_pause(URLContext *s, int pause)
267 {
268     LibRTMPContext *ctx = s->priv_data;
269     RTMP *r = &ctx->rtmp;
270
271     if (!RTMP_Pause(r, pause))
272         return AVERROR_UNKNOWN;
273     return 0;
274 }
275
276 static int64_t rtmp_read_seek(URLContext *s, int stream_index,
277                               int64_t timestamp, int flags)
278 {
279     LibRTMPContext *ctx = s->priv_data;
280     RTMP *r = &ctx->rtmp;
281
282     if (flags & AVSEEK_FLAG_BYTE)
283         return AVERROR(ENOSYS);
284
285     /* seeks are in milliseconds */
286     if (stream_index < 0)
287         timestamp = av_rescale_rnd(timestamp, 1000, AV_TIME_BASE,
288             flags & AVSEEK_FLAG_BACKWARD ? AV_ROUND_DOWN : AV_ROUND_UP);
289
290     if (!RTMP_SendSeek(r, timestamp))
291         return AVERROR_UNKNOWN;
292     return timestamp;
293 }
294
295 static int rtmp_get_file_handle(URLContext *s)
296 {
297     LibRTMPContext *ctx = s->priv_data;
298     RTMP *r = &ctx->rtmp;
299
300     return RTMP_Socket(r);
301 }
302
303 #define OFFSET(x) offsetof(LibRTMPContext, x)
304 #define DEC AV_OPT_FLAG_DECODING_PARAM
305 #define ENC AV_OPT_FLAG_ENCODING_PARAM
306 static const AVOption options[] = {
307     {"rtmp_app", "Name of application to connect to on the RTMP server", OFFSET(app), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
308     {"rtmp_buffer", "Set buffer time in milliseconds. The default is 3000.", OFFSET(client_buffer_time), AV_OPT_TYPE_STRING, {.str = "3000"}, 0, 0, DEC|ENC},
309     {"rtmp_conn", "Append arbitrary AMF data to the Connect message", OFFSET(conn), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
310     {"rtmp_flashver", "Version of the Flash plugin used to run the SWF player.", OFFSET(flashver), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
311     {"rtmp_live", "Specify that the media is a live stream.", OFFSET(live), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtmp_live"},
312     {"any", "both", 0, AV_OPT_TYPE_CONST, {.i64 = -2}, 0, 0, DEC, "rtmp_live"},
313     {"live", "live stream", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, DEC, "rtmp_live"},
314     {"recorded", "recorded stream", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, DEC, "rtmp_live"},
315     {"rtmp_pageurl", "URL of the web page in which the media was embedded. By default no value will be sent.", OFFSET(pageurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
316     {"rtmp_playpath", "Stream identifier to play or to publish", OFFSET(playpath), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
317     {"rtmp_subscribe", "Name of live stream to subscribe to. Defaults to rtmp_playpath.", OFFSET(subscribe), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
318     {"rtmp_swfurl", "URL of the SWF player. By default no value will be sent", OFFSET(swfurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
319     {"rtmp_swfverify", "URL to player swf file, compute hash/size automatically. (unimplemented)", OFFSET(swfverify), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
320     {"rtmp_tcurl", "URL of the target stream. Defaults to proto://host[:port]/app.", OFFSET(tcurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
321     {"rtmp_buffer_size", "set buffer size in bytes", OFFSET(buffer_size), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, DEC|ENC },
322     { NULL },
323 };
324
325 #define RTMP_CLASS(flavor)\
326 static const AVClass lib ## flavor ## _class = {\
327     .class_name = "lib" #flavor " protocol",\
328     .item_name  = av_default_item_name,\
329     .option     = options,\
330     .version    = LIBAVUTIL_VERSION_INT,\
331 };
332
333 RTMP_CLASS(rtmp)
334 URLProtocol ff_librtmp_protocol = {
335     .name                = "rtmp",
336     .url_open            = rtmp_open,
337     .url_read            = rtmp_read,
338     .url_write           = rtmp_write,
339     .url_close           = rtmp_close,
340     .url_read_pause      = rtmp_read_pause,
341     .url_read_seek       = rtmp_read_seek,
342     .url_get_file_handle = rtmp_get_file_handle,
343     .priv_data_size      = sizeof(LibRTMPContext),
344     .priv_data_class     = &librtmp_class,
345     .flags               = URL_PROTOCOL_FLAG_NETWORK,
346 };
347
348 RTMP_CLASS(rtmpt)
349 URLProtocol ff_librtmpt_protocol = {
350     .name                = "rtmpt",
351     .url_open            = rtmp_open,
352     .url_read            = rtmp_read,
353     .url_write           = rtmp_write,
354     .url_close           = rtmp_close,
355     .url_read_pause      = rtmp_read_pause,
356     .url_read_seek       = rtmp_read_seek,
357     .url_get_file_handle = rtmp_get_file_handle,
358     .priv_data_size      = sizeof(LibRTMPContext),
359     .priv_data_class     = &librtmpt_class,
360     .flags               = URL_PROTOCOL_FLAG_NETWORK,
361 };
362
363 RTMP_CLASS(rtmpe)
364 URLProtocol ff_librtmpe_protocol = {
365     .name                = "rtmpe",
366     .url_open            = rtmp_open,
367     .url_read            = rtmp_read,
368     .url_write           = rtmp_write,
369     .url_close           = rtmp_close,
370     .url_read_pause      = rtmp_read_pause,
371     .url_read_seek       = rtmp_read_seek,
372     .url_get_file_handle = rtmp_get_file_handle,
373     .priv_data_size      = sizeof(LibRTMPContext),
374     .priv_data_class     = &librtmpe_class,
375     .flags               = URL_PROTOCOL_FLAG_NETWORK,
376 };
377
378 RTMP_CLASS(rtmpte)
379 URLProtocol ff_librtmpte_protocol = {
380     .name                = "rtmpte",
381     .url_open            = rtmp_open,
382     .url_read            = rtmp_read,
383     .url_write           = rtmp_write,
384     .url_close           = rtmp_close,
385     .url_read_pause      = rtmp_read_pause,
386     .url_read_seek       = rtmp_read_seek,
387     .url_get_file_handle = rtmp_get_file_handle,
388     .priv_data_size      = sizeof(LibRTMPContext),
389     .priv_data_class     = &librtmpte_class,
390     .flags               = URL_PROTOCOL_FLAG_NETWORK,
391 };
392
393 RTMP_CLASS(rtmps)
394 URLProtocol ff_librtmps_protocol = {
395     .name                = "rtmps",
396     .url_open            = rtmp_open,
397     .url_read            = rtmp_read,
398     .url_write           = rtmp_write,
399     .url_close           = rtmp_close,
400     .url_read_pause      = rtmp_read_pause,
401     .url_read_seek       = rtmp_read_seek,
402     .url_get_file_handle = rtmp_get_file_handle,
403     .priv_data_size      = sizeof(LibRTMPContext),
404     .priv_data_class     = &librtmps_class,
405     .flags               = URL_PROTOCOL_FLAG_NETWORK,
406 };