2 * RTMP network protocol
3 * Copyright (c) 2009 Konstantin Shishkov
5 * This file is part of Libav.
7 * Libav 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.
12 * Libav 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.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavcodec/bytestream.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/base64.h"
30 #include "libavutil/intfloat.h"
31 #include "libavutil/lfg.h"
32 #include "libavutil/md5.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/random_seed.h"
35 #include "libavutil/sha.h"
43 #include "rtmpcrypt.h"
51 #define APP_MAX_LENGTH 128
52 #define PLAYPATH_MAX_LENGTH 256
53 #define TCURL_MAX_LENGTH 512
54 #define FLASHVER_MAX_LENGTH 64
55 #define RTMP_PKTDATA_DEFAULT_SIZE 4096
56 #define RTMP_HEADER 11
58 /** RTMP protocol handler state */
60 STATE_START, ///< client has not done anything yet
61 STATE_HANDSHAKED, ///< client has performed handshake
62 STATE_FCPUBLISH, ///< client FCPublishing stream (for output)
63 STATE_PLAYING, ///< client has started receiving multimedia data from server
64 STATE_SEEKING, ///< client has started the seek operation. Back on STATE_PLAYING when the time comes
65 STATE_PUBLISHING, ///< client has started sending multimedia data to server (for output)
66 STATE_RECEIVING, ///< received a publish command (for input)
67 STATE_SENDING, ///< received a play command (for output)
68 STATE_STOPPED, ///< the broadcast has been stopped
71 typedef struct TrackedMethod {
76 /** protocol handler context */
77 typedef struct RTMPContext {
79 URLContext* stream; ///< TCP stream used in interactions with RTMP server
80 RTMPPacket *prev_pkt[2]; ///< packet history used when reading and sending packets ([0] for reading, [1] for writing)
81 int nb_prev_pkt[2]; ///< number of elements in prev_pkt
82 int in_chunk_size; ///< size of the chunks incoming RTMP packets are divided into
83 int out_chunk_size; ///< size of the chunks outgoing RTMP packets are divided into
84 int is_input; ///< input/output flag
85 char *playpath; ///< stream identifier to play (with possible "mp4:" prefix)
86 int live; ///< 0: recorded, -1: live, -2: both
87 char *app; ///< name of application
88 char *conn; ///< append arbitrary AMF data to the Connect message
89 ClientState state; ///< current state
90 int stream_id; ///< ID assigned by the server for the stream
91 uint8_t* flv_data; ///< buffer with data for demuxer
92 int flv_size; ///< current buffer size
93 int flv_off; ///< number of bytes read from current buffer
94 int flv_nb_packets; ///< number of flv packets published
95 RTMPPacket out_pkt; ///< rtmp packet, created from flv a/v or metadata (for output)
96 uint32_t client_report_size; ///< number of bytes after which client should report to server
97 uint32_t bytes_read; ///< number of bytes read from server
98 uint32_t last_bytes_read; ///< number of bytes read last reported to server
99 uint32_t last_timestamp; ///< last timestamp received in a packet
100 int skip_bytes; ///< number of bytes to skip from the input FLV stream in the next write call
101 int has_audio; ///< presence of audio data
102 int has_video; ///< presence of video data
103 int received_metadata; ///< Indicates if we have received metadata about the streams
104 uint8_t flv_header[RTMP_HEADER]; ///< partial incoming flv packet header
105 int flv_header_bytes; ///< number of initialized bytes in flv_header
106 int nb_invokes; ///< keeps track of invoke messages
107 char* tcurl; ///< url of the target stream
108 char* flashver; ///< version of the flash plugin
109 char* swfhash; ///< SHA256 hash of the decompressed SWF file (32 bytes)
110 int swfhash_len; ///< length of the SHA256 hash
111 int swfsize; ///< size of the decompressed SWF file
112 char* swfurl; ///< url of the swf player
113 char* swfverify; ///< URL to player swf file, compute hash/size automatically
114 char swfverification[42]; ///< hash of the SWF verification
115 char* pageurl; ///< url of the web page
116 char* subscribe; ///< name of live stream to subscribe
117 int server_bw; ///< server bandwidth
118 int client_buffer_time; ///< client buffer time in ms
119 int flush_interval; ///< number of packets flushed in the same request (RTMPT only)
120 int encrypted; ///< use an encrypted connection (RTMPE only)
121 TrackedMethod*tracked_methods; ///< tracked methods buffer
122 int nb_tracked_methods; ///< number of tracked methods
123 int tracked_methods_size; ///< size of the tracked methods buffer
124 int listen; ///< listen mode flag
125 int listen_timeout; ///< listen timeout to wait for new connections
126 int nb_streamid; ///< The next stream id to return on createStream calls
127 double duration; ///< Duration of the stream in seconds as returned by the server (only valid if non-zero)
130 char auth_params[500];
135 #define PLAYER_KEY_OPEN_PART_LEN 30 ///< length of partial key used for first client digest signing
136 /** Client key used for digest signing */
137 static const uint8_t rtmp_player_key[] = {
138 'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
139 'F', 'l', 'a', 's', 'h', ' ', 'P', 'l', 'a', 'y', 'e', 'r', ' ', '0', '0', '1',
141 0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
142 0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
143 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
146 #define SERVER_KEY_OPEN_PART_LEN 36 ///< length of partial key used for first server digest signing
147 /** Key used for RTMP server digest signing */
148 static const uint8_t rtmp_server_key[] = {
149 'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
150 'F', 'l', 'a', 's', 'h', ' ', 'M', 'e', 'd', 'i', 'a', ' ',
151 'S', 'e', 'r', 'v', 'e', 'r', ' ', '0', '0', '1',
153 0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
154 0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
155 0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
158 static int handle_chunk_size(URLContext *s, RTMPPacket *pkt);
160 static int add_tracked_method(RTMPContext *rt, const char *name, int id)
164 if (rt->nb_tracked_methods + 1 > rt->tracked_methods_size) {
165 rt->tracked_methods_size = (rt->nb_tracked_methods + 1) * 2;
166 if ((err = av_reallocp(&rt->tracked_methods, rt->tracked_methods_size *
167 sizeof(*rt->tracked_methods))) < 0) {
168 rt->nb_tracked_methods = 0;
169 rt->tracked_methods_size = 0;
174 rt->tracked_methods[rt->nb_tracked_methods].name = av_strdup(name);
175 if (!rt->tracked_methods[rt->nb_tracked_methods].name)
176 return AVERROR(ENOMEM);
177 rt->tracked_methods[rt->nb_tracked_methods].id = id;
178 rt->nb_tracked_methods++;
183 static void del_tracked_method(RTMPContext *rt, int index)
185 memmove(&rt->tracked_methods[index], &rt->tracked_methods[index + 1],
186 sizeof(*rt->tracked_methods) * (rt->nb_tracked_methods - index - 1));
187 rt->nb_tracked_methods--;
190 static int find_tracked_method(URLContext *s, RTMPPacket *pkt, int offset,
191 char **tracked_method)
193 RTMPContext *rt = s->priv_data;
199 bytestream2_init(&gbc, pkt->data + offset, pkt->size - offset);
200 if ((ret = ff_amf_read_number(&gbc, &pkt_id)) < 0)
203 for (i = 0; i < rt->nb_tracked_methods; i++) {
204 if (rt->tracked_methods[i].id != pkt_id)
207 *tracked_method = rt->tracked_methods[i].name;
208 del_tracked_method(rt, i);
215 static void free_tracked_methods(RTMPContext *rt)
219 for (i = 0; i < rt->nb_tracked_methods; i ++)
220 av_free(rt->tracked_methods[i].name);
221 av_free(rt->tracked_methods);
222 rt->tracked_methods = NULL;
223 rt->tracked_methods_size = 0;
224 rt->nb_tracked_methods = 0;
227 static int rtmp_send_packet(RTMPContext *rt, RTMPPacket *pkt, int track)
231 if (pkt->type == RTMP_PT_INVOKE && track) {
237 bytestream2_init(&gbc, pkt->data, pkt->size);
238 if ((ret = ff_amf_read_string(&gbc, name, sizeof(name), &len)) < 0)
241 if ((ret = ff_amf_read_number(&gbc, &pkt_id)) < 0)
244 if ((ret = add_tracked_method(rt, name, pkt_id)) < 0)
248 ret = ff_rtmp_packet_write(rt->stream, pkt, rt->out_chunk_size,
249 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
251 ff_rtmp_packet_destroy(pkt);
255 static int rtmp_write_amf_data(URLContext *s, char *param, uint8_t **p)
260 /* The type must be B for Boolean, N for number, S for string, O for
261 * object, or Z for null. For Booleans the data must be either 0 or 1 for
262 * FALSE or TRUE, respectively. Likewise for Objects the data must be
263 * 0 or 1 to end or begin an object, respectively. Data items in subobjects
264 * may be named, by prefixing the type with 'N' and specifying the name
265 * before the value (ie. NB:myFlag:1). This option may be used multiple times
266 * to construct arbitrary AMF sequences. */
267 if (param[0] && param[1] == ':') {
270 } else if (param[0] == 'N' && param[1] && param[2] == ':') {
273 value = strchr(field, ':');
279 ff_amf_write_field_name(p, field);
286 ff_amf_write_bool(p, value[0] != '0');
289 ff_amf_write_string(p, value);
292 ff_amf_write_number(p, strtod(value, NULL));
295 ff_amf_write_null(p);
299 ff_amf_write_object_start(p);
301 ff_amf_write_object_end(p);
311 av_log(s, AV_LOG_ERROR, "Invalid AMF parameter: %s\n", param);
312 return AVERROR(EINVAL);
316 * Generate 'connect' call and send it to the server.
318 static int gen_connect(URLContext *s, RTMPContext *rt)
324 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
330 ff_amf_write_string(&p, "connect");
331 ff_amf_write_number(&p, ++rt->nb_invokes);
332 ff_amf_write_object_start(&p);
333 ff_amf_write_field_name(&p, "app");
334 ff_amf_write_string2(&p, rt->app, rt->auth_params);
337 ff_amf_write_field_name(&p, "type");
338 ff_amf_write_string(&p, "nonprivate");
340 ff_amf_write_field_name(&p, "flashVer");
341 ff_amf_write_string(&p, rt->flashver);
344 ff_amf_write_field_name(&p, "swfUrl");
345 ff_amf_write_string(&p, rt->swfurl);
348 ff_amf_write_field_name(&p, "tcUrl");
349 ff_amf_write_string2(&p, rt->tcurl, rt->auth_params);
351 ff_amf_write_field_name(&p, "fpad");
352 ff_amf_write_bool(&p, 0);
353 ff_amf_write_field_name(&p, "capabilities");
354 ff_amf_write_number(&p, 15.0);
356 /* Tell the server we support all the audio codecs except
357 * SUPPORT_SND_INTEL (0x0008) and SUPPORT_SND_UNUSED (0x0010)
358 * which are unused in the RTMP protocol implementation. */
359 ff_amf_write_field_name(&p, "audioCodecs");
360 ff_amf_write_number(&p, 4071.0);
361 ff_amf_write_field_name(&p, "videoCodecs");
362 ff_amf_write_number(&p, 252.0);
363 ff_amf_write_field_name(&p, "videoFunction");
364 ff_amf_write_number(&p, 1.0);
367 ff_amf_write_field_name(&p, "pageUrl");
368 ff_amf_write_string(&p, rt->pageurl);
371 ff_amf_write_object_end(&p);
374 char *param = rt->conn;
376 // Write arbitrary AMF data to the Connect message.
379 param += strspn(param, " ");
382 sep = strchr(param, ' ');
385 if ((ret = rtmp_write_amf_data(s, param, &p)) < 0) {
386 // Invalid AMF parameter.
387 ff_rtmp_packet_destroy(&pkt);
398 pkt.size = p - pkt.data;
400 return rtmp_send_packet(rt, &pkt, 1);
403 static int read_connect(URLContext *s, RTMPContext *rt)
405 RTMPPacket pkt = { 0 };
415 if ((ret = ff_rtmp_packet_read(rt->stream, &pkt, rt->in_chunk_size,
416 &rt->prev_pkt[0], &rt->nb_prev_pkt[0])) < 0)
419 if (pkt.type == RTMP_PT_CHUNK_SIZE) {
420 if ((ret = handle_chunk_size(s, &pkt)) < 0)
422 ff_rtmp_packet_destroy(&pkt);
423 if ((ret = ff_rtmp_packet_read(rt->stream, &pkt, rt->in_chunk_size,
424 &rt->prev_pkt[0], &rt->nb_prev_pkt[0])) < 0)
429 bytestream2_init(&gbc, cp, pkt.size);
430 if (ff_amf_read_string(&gbc, command, sizeof(command), &stringlen)) {
431 av_log(s, AV_LOG_ERROR, "Unable to read command string\n");
432 ff_rtmp_packet_destroy(&pkt);
433 return AVERROR_INVALIDDATA;
435 if (strcmp(command, "connect")) {
436 av_log(s, AV_LOG_ERROR, "Expecting connect, got %s\n", command);
437 ff_rtmp_packet_destroy(&pkt);
438 return AVERROR_INVALIDDATA;
440 ret = ff_amf_read_number(&gbc, &seqnum);
442 av_log(s, AV_LOG_WARNING, "SeqNum not found\n");
443 /* Here one could parse an AMF Object with data as flashVers and others. */
444 ret = ff_amf_get_field_value(gbc.buffer,
445 gbc.buffer + bytestream2_get_bytes_left(&gbc),
446 "app", tmpstr, sizeof(tmpstr));
448 av_log(s, AV_LOG_WARNING, "App field not found in connect\n");
449 if (!ret && strcmp(tmpstr, rt->app))
450 av_log(s, AV_LOG_WARNING, "App field don't match up: %s <-> %s\n",
452 ff_rtmp_packet_destroy(&pkt);
454 // Send Window Acknowledgement Size (as defined in speficication)
455 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
456 RTMP_PT_SERVER_BW, 0, 4)) < 0)
459 bytestream_put_be32(&p, rt->server_bw);
460 pkt.size = p - pkt.data;
461 ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
462 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
463 ff_rtmp_packet_destroy(&pkt);
466 // Send Peer Bandwidth
467 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
468 RTMP_PT_CLIENT_BW, 0, 5)) < 0)
471 bytestream_put_be32(&p, rt->server_bw);
472 bytestream_put_byte(&p, 2); // dynamic
473 pkt.size = p - pkt.data;
474 ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
475 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
476 ff_rtmp_packet_destroy(&pkt);
481 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
482 RTMP_PT_PING, 0, 6)) < 0)
486 bytestream_put_be16(&p, 0); // 0 -> Stream Begin
487 bytestream_put_be32(&p, 0);
488 ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
489 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
490 ff_rtmp_packet_destroy(&pkt);
495 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
496 RTMP_PT_CHUNK_SIZE, 0, 4)) < 0)
500 bytestream_put_be32(&p, rt->out_chunk_size);
501 ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
502 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
503 ff_rtmp_packet_destroy(&pkt);
507 // Send _result NetConnection.Connect.Success to connect
508 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
510 RTMP_PKTDATA_DEFAULT_SIZE)) < 0)
514 ff_amf_write_string(&p, "_result");
515 ff_amf_write_number(&p, seqnum);
517 ff_amf_write_object_start(&p);
518 ff_amf_write_field_name(&p, "fmsVer");
519 ff_amf_write_string(&p, "FMS/3,0,1,123");
520 ff_amf_write_field_name(&p, "capabilities");
521 ff_amf_write_number(&p, 31);
522 ff_amf_write_object_end(&p);
524 ff_amf_write_object_start(&p);
525 ff_amf_write_field_name(&p, "level");
526 ff_amf_write_string(&p, "status");
527 ff_amf_write_field_name(&p, "code");
528 ff_amf_write_string(&p, "NetConnection.Connect.Success");
529 ff_amf_write_field_name(&p, "description");
530 ff_amf_write_string(&p, "Connection succeeded.");
531 ff_amf_write_field_name(&p, "objectEncoding");
532 ff_amf_write_number(&p, 0);
533 ff_amf_write_object_end(&p);
535 pkt.size = p - pkt.data;
536 ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
537 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
538 ff_rtmp_packet_destroy(&pkt);
542 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
543 RTMP_PT_INVOKE, 0, 30)) < 0)
546 ff_amf_write_string(&p, "onBWDone");
547 ff_amf_write_number(&p, 0);
548 ff_amf_write_null(&p);
549 ff_amf_write_number(&p, 8192);
550 pkt.size = p - pkt.data;
551 ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
552 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
553 ff_rtmp_packet_destroy(&pkt);
559 * Generate 'releaseStream' call and send it to the server. It should make
560 * the server release some channel for media streams.
562 static int gen_release_stream(URLContext *s, RTMPContext *rt)
568 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
569 0, 29 + strlen(rt->playpath))) < 0)
572 av_log(s, AV_LOG_DEBUG, "Releasing stream...\n");
574 ff_amf_write_string(&p, "releaseStream");
575 ff_amf_write_number(&p, ++rt->nb_invokes);
576 ff_amf_write_null(&p);
577 ff_amf_write_string(&p, rt->playpath);
579 return rtmp_send_packet(rt, &pkt, 1);
583 * Generate 'FCPublish' call and send it to the server. It should make
584 * the server preapare for receiving media streams.
586 static int gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
592 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
593 0, 25 + strlen(rt->playpath))) < 0)
596 av_log(s, AV_LOG_DEBUG, "FCPublish stream...\n");
598 ff_amf_write_string(&p, "FCPublish");
599 ff_amf_write_number(&p, ++rt->nb_invokes);
600 ff_amf_write_null(&p);
601 ff_amf_write_string(&p, rt->playpath);
603 return rtmp_send_packet(rt, &pkt, 1);
607 * Generate 'FCUnpublish' call and send it to the server. It should make
608 * the server destroy stream.
610 static int gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
616 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
617 0, 27 + strlen(rt->playpath))) < 0)
620 av_log(s, AV_LOG_DEBUG, "UnPublishing stream...\n");
622 ff_amf_write_string(&p, "FCUnpublish");
623 ff_amf_write_number(&p, ++rt->nb_invokes);
624 ff_amf_write_null(&p);
625 ff_amf_write_string(&p, rt->playpath);
627 return rtmp_send_packet(rt, &pkt, 0);
631 * Generate 'createStream' call and send it to the server. It should make
632 * the server allocate some channel for media streams.
634 static int gen_create_stream(URLContext *s, RTMPContext *rt)
640 av_log(s, AV_LOG_DEBUG, "Creating stream...\n");
642 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
647 ff_amf_write_string(&p, "createStream");
648 ff_amf_write_number(&p, ++rt->nb_invokes);
649 ff_amf_write_null(&p);
651 return rtmp_send_packet(rt, &pkt, 1);
656 * Generate 'deleteStream' call and send it to the server. It should make
657 * the server remove some channel for media streams.
659 static int gen_delete_stream(URLContext *s, RTMPContext *rt)
665 av_log(s, AV_LOG_DEBUG, "Deleting stream...\n");
667 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
672 ff_amf_write_string(&p, "deleteStream");
673 ff_amf_write_number(&p, ++rt->nb_invokes);
674 ff_amf_write_null(&p);
675 ff_amf_write_number(&p, rt->stream_id);
677 return rtmp_send_packet(rt, &pkt, 0);
681 * Generate 'getStreamLength' call and send it to the server. If the server
682 * knows the duration of the selected stream, it will reply with the duration
685 static int gen_get_stream_length(URLContext *s, RTMPContext *rt)
691 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE,
692 0, 31 + strlen(rt->playpath))) < 0)
696 ff_amf_write_string(&p, "getStreamLength");
697 ff_amf_write_number(&p, ++rt->nb_invokes);
698 ff_amf_write_null(&p);
699 ff_amf_write_string(&p, rt->playpath);
701 return rtmp_send_packet(rt, &pkt, 1);
705 * Generate client buffer time and send it to the server.
707 static int gen_buffer_time(URLContext *s, RTMPContext *rt)
713 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
718 bytestream_put_be16(&p, 3);
719 bytestream_put_be32(&p, rt->stream_id);
720 bytestream_put_be32(&p, rt->client_buffer_time);
722 return rtmp_send_packet(rt, &pkt, 0);
726 * Generate 'play' call and send it to the server, then ping the server
727 * to start actual playing.
729 static int gen_play(URLContext *s, RTMPContext *rt)
735 av_log(s, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
737 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE,
738 0, 29 + strlen(rt->playpath))) < 0)
741 pkt.extra = rt->stream_id;
744 ff_amf_write_string(&p, "play");
745 ff_amf_write_number(&p, ++rt->nb_invokes);
746 ff_amf_write_null(&p);
747 ff_amf_write_string(&p, rt->playpath);
748 ff_amf_write_number(&p, rt->live * 1000);
750 return rtmp_send_packet(rt, &pkt, 1);
753 static int gen_seek(URLContext *s, RTMPContext *rt, int64_t timestamp)
759 av_log(s, AV_LOG_DEBUG, "Sending seek command for timestamp %"PRId64"\n",
762 if ((ret = ff_rtmp_packet_create(&pkt, 3, RTMP_PT_INVOKE, 0, 26)) < 0)
765 pkt.extra = rt->stream_id;
768 ff_amf_write_string(&p, "seek");
769 ff_amf_write_number(&p, 0); //no tracking back responses
770 ff_amf_write_null(&p); //as usual, the first null param
771 ff_amf_write_number(&p, timestamp); //where we want to jump
773 return rtmp_send_packet(rt, &pkt, 1);
777 * Generate a pause packet that either pauses or unpauses the current stream.
779 static int gen_pause(URLContext *s, RTMPContext *rt, int pause, uint32_t timestamp)
785 av_log(s, AV_LOG_DEBUG, "Sending pause command for timestamp %d\n",
788 if ((ret = ff_rtmp_packet_create(&pkt, 3, RTMP_PT_INVOKE, 0, 29)) < 0)
791 pkt.extra = rt->stream_id;
794 ff_amf_write_string(&p, "pause");
795 ff_amf_write_number(&p, 0); //no tracking back responses
796 ff_amf_write_null(&p); //as usual, the first null param
797 ff_amf_write_bool(&p, pause); // pause or unpause
798 ff_amf_write_number(&p, timestamp); //where we pause the stream
800 return rtmp_send_packet(rt, &pkt, 1);
804 * Generate 'publish' call and send it to the server.
806 static int gen_publish(URLContext *s, RTMPContext *rt)
812 av_log(s, AV_LOG_DEBUG, "Sending publish command for '%s'\n", rt->playpath);
814 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE,
815 0, 30 + strlen(rt->playpath))) < 0)
818 pkt.extra = rt->stream_id;
821 ff_amf_write_string(&p, "publish");
822 ff_amf_write_number(&p, ++rt->nb_invokes);
823 ff_amf_write_null(&p);
824 ff_amf_write_string(&p, rt->playpath);
825 ff_amf_write_string(&p, "live");
827 return rtmp_send_packet(rt, &pkt, 1);
831 * Generate ping reply and send it to the server.
833 static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
839 if (ppkt->size < 6) {
840 av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
842 return AVERROR_INVALIDDATA;
845 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
846 ppkt->timestamp + 1, 6)) < 0)
850 bytestream_put_be16(&p, 7);
851 bytestream_put_be32(&p, AV_RB32(ppkt->data+2));
853 return rtmp_send_packet(rt, &pkt, 0);
857 * Generate SWF verification message and send it to the server.
859 static int gen_swf_verification(URLContext *s, RTMPContext *rt)
865 av_log(s, AV_LOG_DEBUG, "Sending SWF verification...\n");
866 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
871 bytestream_put_be16(&p, 27);
872 memcpy(p, rt->swfverification, 42);
874 return rtmp_send_packet(rt, &pkt, 0);
878 * Generate server bandwidth message and send it to the server.
880 static int gen_server_bw(URLContext *s, RTMPContext *rt)
886 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_SERVER_BW,
891 bytestream_put_be32(&p, rt->server_bw);
893 return rtmp_send_packet(rt, &pkt, 0);
897 * Generate check bandwidth message and send it to the server.
899 static int gen_check_bw(URLContext *s, RTMPContext *rt)
905 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
910 ff_amf_write_string(&p, "_checkbw");
911 ff_amf_write_number(&p, ++rt->nb_invokes);
912 ff_amf_write_null(&p);
914 return rtmp_send_packet(rt, &pkt, 1);
918 * Generate report on bytes read so far and send it to the server.
920 static int gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)
926 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_BYTES_READ,
931 bytestream_put_be32(&p, rt->bytes_read);
933 return rtmp_send_packet(rt, &pkt, 0);
936 static int gen_fcsubscribe_stream(URLContext *s, RTMPContext *rt,
937 const char *subscribe)
943 if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
944 0, 27 + strlen(subscribe))) < 0)
948 ff_amf_write_string(&p, "FCSubscribe");
949 ff_amf_write_number(&p, ++rt->nb_invokes);
950 ff_amf_write_null(&p);
951 ff_amf_write_string(&p, subscribe);
953 return rtmp_send_packet(rt, &pkt, 1);
956 int ff_rtmp_calc_digest(const uint8_t *src, int len, int gap,
957 const uint8_t *key, int keylen, uint8_t *dst)
960 uint8_t hmac_buf[64+32] = {0};
963 sha = av_sha_alloc();
965 return AVERROR(ENOMEM);
968 memcpy(hmac_buf, key, keylen);
970 av_sha_init(sha, 256);
971 av_sha_update(sha,key, keylen);
972 av_sha_final(sha, hmac_buf);
974 for (i = 0; i < 64; i++)
975 hmac_buf[i] ^= HMAC_IPAD_VAL;
977 av_sha_init(sha, 256);
978 av_sha_update(sha, hmac_buf, 64);
980 av_sha_update(sha, src, len);
981 } else { //skip 32 bytes used for storing digest
982 av_sha_update(sha, src, gap);
983 av_sha_update(sha, src + gap + 32, len - gap - 32);
985 av_sha_final(sha, hmac_buf + 64);
987 for (i = 0; i < 64; i++)
988 hmac_buf[i] ^= HMAC_IPAD_VAL ^ HMAC_OPAD_VAL; //reuse XORed key for opad
989 av_sha_init(sha, 256);
990 av_sha_update(sha, hmac_buf, 64+32);
991 av_sha_final(sha, dst);
998 int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off, int mod_val,
1001 int i, digest_pos = 0;
1003 for (i = 0; i < 4; i++)
1004 digest_pos += buf[i + off];
1005 digest_pos = digest_pos % mod_val + add_val;
1011 * Put HMAC-SHA2 digest of packet data (except for the bytes where this digest
1012 * will be stored) into that packet.
1014 * @param buf handshake data (1536 bytes)
1015 * @param encrypted use an encrypted connection (RTMPE)
1016 * @return offset to the digest inside input data
1018 static int rtmp_handshake_imprint_with_digest(uint8_t *buf, int encrypted)
1020 int ret, digest_pos;
1023 digest_pos = ff_rtmp_calc_digest_pos(buf, 772, 728, 776);
1025 digest_pos = ff_rtmp_calc_digest_pos(buf, 8, 728, 12);
1027 ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
1028 rtmp_player_key, PLAYER_KEY_OPEN_PART_LEN,
1037 * Verify that the received server response has the expected digest value.
1039 * @param buf handshake data received from the server (1536 bytes)
1040 * @param off position to search digest offset from
1041 * @return 0 if digest is valid, digest position otherwise
1043 static int rtmp_validate_digest(uint8_t *buf, int off)
1046 int ret, digest_pos;
1048 digest_pos = ff_rtmp_calc_digest_pos(buf, off, 728, off + 4);
1050 ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
1051 rtmp_server_key, SERVER_KEY_OPEN_PART_LEN,
1056 if (!memcmp(digest, buf + digest_pos, 32))
1061 static int rtmp_calc_swf_verification(URLContext *s, RTMPContext *rt,
1067 if (rt->swfhash_len != 32) {
1068 av_log(s, AV_LOG_ERROR,
1069 "Hash of the decompressed SWF file is not 32 bytes long.\n");
1070 return AVERROR(EINVAL);
1073 p = &rt->swfverification[0];
1074 bytestream_put_byte(&p, 1);
1075 bytestream_put_byte(&p, 1);
1076 bytestream_put_be32(&p, rt->swfsize);
1077 bytestream_put_be32(&p, rt->swfsize);
1079 if ((ret = ff_rtmp_calc_digest(rt->swfhash, 32, 0, buf, 32, p)) < 0)
1086 static int rtmp_uncompress_swfplayer(uint8_t *in_data, int64_t in_size,
1087 uint8_t **out_data, int64_t *out_size)
1089 z_stream zs = { 0 };
1094 zs.avail_in = in_size;
1095 zs.next_in = in_data;
1096 ret = inflateInit(&zs);
1098 return AVERROR_UNKNOWN;
1101 uint8_t tmp_buf[16384];
1103 zs.avail_out = sizeof(tmp_buf);
1104 zs.next_out = tmp_buf;
1106 ret = inflate(&zs, Z_NO_FLUSH);
1107 if (ret != Z_OK && ret != Z_STREAM_END) {
1108 ret = AVERROR_UNKNOWN;
1112 size = sizeof(tmp_buf) - zs.avail_out;
1113 if (!(ptr = av_realloc(*out_data, *out_size + size))) {
1114 ret = AVERROR(ENOMEM);
1119 memcpy(*out_data + *out_size, tmp_buf, size);
1121 } while (zs.avail_out == 0);
1129 static int rtmp_calc_swfhash(URLContext *s)
1131 RTMPContext *rt = s->priv_data;
1132 uint8_t *in_data = NULL, *out_data = NULL, *swfdata;
1133 int64_t in_size, out_size;
1139 /* Get the SWF player file. */
1140 if ((ret = ffurl_open(&stream, rt->swfverify, AVIO_FLAG_READ,
1141 &s->interrupt_callback, NULL)) < 0) {
1142 av_log(s, AV_LOG_ERROR, "Cannot open connection %s.\n", rt->swfverify);
1146 if ((in_size = ffurl_seek(stream, 0, AVSEEK_SIZE)) < 0) {
1151 if (!(in_data = av_malloc(in_size))) {
1152 ret = AVERROR(ENOMEM);
1156 if ((ret = ffurl_read_complete(stream, in_data, in_size)) < 0)
1160 ret = AVERROR_INVALIDDATA;
1164 if (!memcmp(in_data, "CWS", 3)) {
1165 /* Decompress the SWF player file using Zlib. */
1166 if (!(out_data = av_malloc(8))) {
1167 ret = AVERROR(ENOMEM);
1170 *in_data = 'F'; // magic stuff
1171 memcpy(out_data, in_data, 8);
1175 if ((ret = rtmp_uncompress_swfplayer(in_data + 8, in_size - 8,
1176 &out_data, &out_size)) < 0)
1179 av_log(s, AV_LOG_ERROR,
1180 "Zlib is required for decompressing the SWF player file.\n");
1181 ret = AVERROR(EINVAL);
1191 /* Compute the SHA256 hash of the SWF player file. */
1192 if ((ret = ff_rtmp_calc_digest(swfdata, swfsize, 0,
1193 "Genuine Adobe Flash Player 001", 30,
1197 /* Set SWFVerification parameters. */
1198 av_opt_set_bin(rt, "rtmp_swfhash", swfhash, 32, 0);
1199 rt->swfsize = swfsize;
1203 av_freep(&out_data);
1204 ffurl_close(stream);
1209 * Perform handshake with the server by means of exchanging pseudorandom data
1210 * signed with HMAC-SHA2 digest.
1212 * @return 0 if handshake succeeds, negative value otherwise
1214 static int rtmp_handshake(URLContext *s, RTMPContext *rt)
1217 uint8_t tosend [RTMP_HANDSHAKE_PACKET_SIZE+1] = {
1218 3, // unencrypted data
1219 0, 0, 0, 0, // client uptime
1225 uint8_t clientdata[RTMP_HANDSHAKE_PACKET_SIZE];
1226 uint8_t serverdata[RTMP_HANDSHAKE_PACKET_SIZE+1];
1228 int server_pos, client_pos;
1229 uint8_t digest[32], signature[32];
1232 av_log(s, AV_LOG_DEBUG, "Handshaking...\n");
1234 av_lfg_init(&rnd, 0xDEADC0DE);
1235 // generate handshake packet - 1536 bytes of pseudorandom data
1236 for (i = 9; i <= RTMP_HANDSHAKE_PACKET_SIZE; i++)
1237 tosend[i] = av_lfg_get(&rnd) >> 24;
1239 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1240 /* When the client wants to use RTMPE, we have to change the command
1241 * byte to 0x06 which means to use encrypted data and we have to set
1242 * the flash version to at least 9.0.115.0. */
1249 /* Initialize the Diffie-Hellmann context and generate the public key
1250 * to send to the server. */
1251 if ((ret = ff_rtmpe_gen_pub_key(rt->stream, tosend + 1)) < 0)
1255 client_pos = rtmp_handshake_imprint_with_digest(tosend + 1, rt->encrypted);
1259 if ((ret = ffurl_write(rt->stream, tosend,
1260 RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
1261 av_log(s, AV_LOG_ERROR, "Cannot write RTMP handshake request\n");
1265 if ((ret = ffurl_read_complete(rt->stream, serverdata,
1266 RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
1267 av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
1271 if ((ret = ffurl_read_complete(rt->stream, clientdata,
1272 RTMP_HANDSHAKE_PACKET_SIZE)) < 0) {
1273 av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
1277 av_log(s, AV_LOG_DEBUG, "Type answer %d\n", serverdata[0]);
1278 av_log(s, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
1279 serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
1281 if (rt->is_input && serverdata[5] >= 3) {
1282 server_pos = rtmp_validate_digest(serverdata + 1, 772);
1288 server_pos = rtmp_validate_digest(serverdata + 1, 8);
1293 av_log(s, AV_LOG_ERROR, "Server response validating failed\n");
1294 return AVERROR(EIO);
1298 /* Generate SWFVerification token (SHA256 HMAC hash of decompressed SWF,
1299 * key are the last 32 bytes of the server handshake. */
1301 if ((ret = rtmp_calc_swf_verification(s, rt, serverdata + 1 +
1302 RTMP_HANDSHAKE_PACKET_SIZE - 32)) < 0)
1306 ret = ff_rtmp_calc_digest(tosend + 1 + client_pos, 32, 0,
1307 rtmp_server_key, sizeof(rtmp_server_key),
1312 ret = ff_rtmp_calc_digest(clientdata, RTMP_HANDSHAKE_PACKET_SIZE - 32,
1313 0, digest, 32, signature);
1317 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1318 /* Compute the shared secret key sent by the server and initialize
1319 * the RC4 encryption. */
1320 if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
1321 tosend + 1, type)) < 0)
1324 /* Encrypt the signature received by the server. */
1325 ff_rtmpe_encrypt_sig(rt->stream, signature, digest, serverdata[0]);
1328 if (memcmp(signature, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
1329 av_log(s, AV_LOG_ERROR, "Signature mismatch\n");
1330 return AVERROR(EIO);
1333 for (i = 0; i < RTMP_HANDSHAKE_PACKET_SIZE; i++)
1334 tosend[i] = av_lfg_get(&rnd) >> 24;
1335 ret = ff_rtmp_calc_digest(serverdata + 1 + server_pos, 32, 0,
1336 rtmp_player_key, sizeof(rtmp_player_key),
1341 ret = ff_rtmp_calc_digest(tosend, RTMP_HANDSHAKE_PACKET_SIZE - 32, 0,
1343 tosend + RTMP_HANDSHAKE_PACKET_SIZE - 32);
1347 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1348 /* Encrypt the signature to be send to the server. */
1349 ff_rtmpe_encrypt_sig(rt->stream, tosend +
1350 RTMP_HANDSHAKE_PACKET_SIZE - 32, digest,
1354 // write reply back to the server
1355 if ((ret = ffurl_write(rt->stream, tosend,
1356 RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1359 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1360 /* Set RC4 keys for encryption and update the keystreams. */
1361 if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
1365 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1366 /* Compute the shared secret key sent by the server and initialize
1367 * the RC4 encryption. */
1368 if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
1369 tosend + 1, 1)) < 0)
1372 if (serverdata[0] == 9) {
1373 /* Encrypt the signature received by the server. */
1374 ff_rtmpe_encrypt_sig(rt->stream, signature, digest,
1379 if ((ret = ffurl_write(rt->stream, serverdata + 1,
1380 RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1383 if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1384 /* Set RC4 keys for encryption and update the keystreams. */
1385 if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
1393 static int rtmp_receive_hs_packet(RTMPContext* rt, uint32_t *first_int,
1394 uint32_t *second_int, char *arraydata,
1399 inoutsize = ffurl_read_complete(rt->stream, arraydata,
1400 RTMP_HANDSHAKE_PACKET_SIZE);
1402 return AVERROR(EIO);
1403 if (inoutsize != RTMP_HANDSHAKE_PACKET_SIZE) {
1404 av_log(rt, AV_LOG_ERROR, "Erroneous Message size %d"
1405 " not following standard\n", (int)inoutsize);
1406 return AVERROR(EINVAL);
1409 *first_int = AV_RB32(arraydata);
1410 *second_int = AV_RB32(arraydata + 4);
1414 static int rtmp_send_hs_packet(RTMPContext* rt, uint32_t first_int,
1415 uint32_t second_int, char *arraydata, int size)
1419 AV_WB32(arraydata, first_int);
1420 AV_WB32(arraydata + 4, second_int);
1421 inoutsize = ffurl_write(rt->stream, arraydata,
1422 RTMP_HANDSHAKE_PACKET_SIZE);
1423 if (inoutsize != RTMP_HANDSHAKE_PACKET_SIZE) {
1424 av_log(rt, AV_LOG_ERROR, "Unable to write answer\n");
1425 return AVERROR(EIO);
1432 * rtmp handshake server side
1434 static int rtmp_server_handshake(URLContext *s, RTMPContext *rt)
1436 uint8_t buffer[RTMP_HANDSHAKE_PACKET_SIZE];
1438 uint32_t hs_my_epoch;
1439 uint8_t hs_c1[RTMP_HANDSHAKE_PACKET_SIZE];
1440 uint8_t hs_s1[RTMP_HANDSHAKE_PACKET_SIZE];
1447 inoutsize = ffurl_read_complete(rt->stream, buffer, 1); // Receive C0
1448 if (inoutsize <= 0) {
1449 av_log(s, AV_LOG_ERROR, "Unable to read handshake\n");
1450 return AVERROR(EIO);
1453 if (buffer[0] != 3) {
1454 av_log(s, AV_LOG_ERROR, "RTMP protocol version mismatch\n");
1455 return AVERROR(EIO);
1457 if (ffurl_write(rt->stream, buffer, 1) <= 0) { // Send S0
1458 av_log(s, AV_LOG_ERROR,
1459 "Unable to write answer - RTMP S0\n");
1460 return AVERROR(EIO);
1463 ret = rtmp_receive_hs_packet(rt, &hs_epoch, &zeroes, hs_c1,
1464 RTMP_HANDSHAKE_PACKET_SIZE);
1466 av_log(s, AV_LOG_ERROR, "RTMP Handshake C1 Error\n");
1470 /* By now same epoch will be sent */
1471 hs_my_epoch = hs_epoch;
1472 /* Generate random */
1473 for (randomidx = 8; randomidx < (RTMP_HANDSHAKE_PACKET_SIZE);
1475 AV_WB32(hs_s1 + randomidx, av_get_random_seed());
1477 ret = rtmp_send_hs_packet(rt, hs_my_epoch, 0, hs_s1,
1478 RTMP_HANDSHAKE_PACKET_SIZE);
1480 av_log(s, AV_LOG_ERROR, "RTMP Handshake S1 Error\n");
1484 ret = rtmp_send_hs_packet(rt, hs_epoch, 0, hs_c1,
1485 RTMP_HANDSHAKE_PACKET_SIZE);
1487 av_log(s, AV_LOG_ERROR, "RTMP Handshake S2 Error\n");
1491 ret = rtmp_receive_hs_packet(rt, &temp, &zeroes, buffer,
1492 RTMP_HANDSHAKE_PACKET_SIZE);
1494 av_log(s, AV_LOG_ERROR, "RTMP Handshake C2 Error\n");
1497 if (temp != hs_my_epoch)
1498 av_log(s, AV_LOG_WARNING,
1499 "Erroneous C2 Message epoch does not match up with C1 epoch\n");
1500 if (memcmp(buffer + 8, hs_s1 + 8,
1501 RTMP_HANDSHAKE_PACKET_SIZE - 8))
1502 av_log(s, AV_LOG_WARNING,
1503 "Erroneous C2 Message random does not match up\n");
1508 static int handle_chunk_size(URLContext *s, RTMPPacket *pkt)
1510 RTMPContext *rt = s->priv_data;
1513 if (pkt->size < 4) {
1514 av_log(s, AV_LOG_ERROR,
1515 "Too short chunk size change packet (%d)\n",
1517 return AVERROR_INVALIDDATA;
1520 if (!rt->is_input) {
1521 /* Send the same chunk size change packet back to the server,
1522 * setting the outgoing chunk size to the same as the incoming one. */
1523 if ((ret = ff_rtmp_packet_write(rt->stream, pkt, rt->out_chunk_size,
1524 &rt->prev_pkt[1], &rt->nb_prev_pkt[1])) < 0)
1526 rt->out_chunk_size = AV_RB32(pkt->data);
1529 rt->in_chunk_size = AV_RB32(pkt->data);
1530 if (rt->in_chunk_size <= 0) {
1531 av_log(s, AV_LOG_ERROR, "Incorrect chunk size %d\n",
1533 return AVERROR_INVALIDDATA;
1535 av_log(s, AV_LOG_DEBUG, "New incoming chunk size = %d\n",
1541 static int handle_ping(URLContext *s, RTMPPacket *pkt)
1543 RTMPContext *rt = s->priv_data;
1546 if (pkt->size < 2) {
1547 av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
1549 return AVERROR_INVALIDDATA;
1552 t = AV_RB16(pkt->data);
1554 if ((ret = gen_pong(s, rt, pkt)) < 0)
1556 } else if (t == 26) {
1558 if ((ret = gen_swf_verification(s, rt)) < 0)
1561 av_log(s, AV_LOG_WARNING, "Ignoring SWFVerification request.\n");
1568 static int handle_client_bw(URLContext *s, RTMPPacket *pkt)
1570 RTMPContext *rt = s->priv_data;
1572 if (pkt->size < 4) {
1573 av_log(s, AV_LOG_ERROR,
1574 "Client bandwidth report packet is less than 4 bytes long (%d)\n",
1576 return AVERROR_INVALIDDATA;
1579 rt->client_report_size = AV_RB32(pkt->data);
1580 if (rt->client_report_size <= 0) {
1581 av_log(s, AV_LOG_ERROR, "Incorrect client bandwidth %d\n",
1582 rt->client_report_size);
1583 return AVERROR_INVALIDDATA;
1586 av_log(s, AV_LOG_DEBUG, "Client bandwidth = %d\n", rt->client_report_size);
1587 rt->client_report_size >>= 1;
1592 static int handle_server_bw(URLContext *s, RTMPPacket *pkt)
1594 RTMPContext *rt = s->priv_data;
1596 if (pkt->size < 4) {
1597 av_log(s, AV_LOG_ERROR,
1598 "Too short server bandwidth report packet (%d)\n",
1600 return AVERROR_INVALIDDATA;
1603 rt->server_bw = AV_RB32(pkt->data);
1604 if (rt->server_bw <= 0) {
1605 av_log(s, AV_LOG_ERROR, "Incorrect server bandwidth %d\n",
1607 return AVERROR_INVALIDDATA;
1609 av_log(s, AV_LOG_DEBUG, "Server bandwidth = %d\n", rt->server_bw);
1614 static int do_adobe_auth(RTMPContext *rt, const char *user, const char *salt,
1615 const char *opaque, const char *challenge)
1618 char hashstr[AV_BASE64_SIZE(sizeof(hash))], challenge2[10];
1619 struct AVMD5 *md5 = av_md5_alloc();
1621 return AVERROR(ENOMEM);
1623 snprintf(challenge2, sizeof(challenge2), "%08x", av_get_random_seed());
1626 av_md5_update(md5, user, strlen(user));
1627 av_md5_update(md5, salt, strlen(salt));
1628 av_md5_update(md5, rt->password, strlen(rt->password));
1629 av_md5_final(md5, hash);
1630 av_base64_encode(hashstr, sizeof(hashstr), hash,
1633 av_md5_update(md5, hashstr, strlen(hashstr));
1635 av_md5_update(md5, opaque, strlen(opaque));
1637 av_md5_update(md5, challenge, strlen(challenge));
1638 av_md5_update(md5, challenge2, strlen(challenge2));
1639 av_md5_final(md5, hash);
1640 av_base64_encode(hashstr, sizeof(hashstr), hash,
1642 snprintf(rt->auth_params, sizeof(rt->auth_params),
1643 "?authmod=%s&user=%s&challenge=%s&response=%s",
1644 "adobe", user, challenge2, hashstr);
1646 av_strlcatf(rt->auth_params, sizeof(rt->auth_params),
1647 "&opaque=%s", opaque);
1653 static int do_llnw_auth(RTMPContext *rt, const char *user, const char *nonce)
1656 char hashstr1[33], hashstr2[33];
1657 const char *realm = "live";
1658 const char *method = "publish";
1659 const char *qop = "auth";
1660 const char *nc = "00000001";
1662 struct AVMD5 *md5 = av_md5_alloc();
1664 return AVERROR(ENOMEM);
1666 snprintf(cnonce, sizeof(cnonce), "%08x", av_get_random_seed());
1669 av_md5_update(md5, user, strlen(user));
1670 av_md5_update(md5, ":", 1);
1671 av_md5_update(md5, realm, strlen(realm));
1672 av_md5_update(md5, ":", 1);
1673 av_md5_update(md5, rt->password, strlen(rt->password));
1674 av_md5_final(md5, hash);
1675 ff_data_to_hex(hashstr1, hash, 16, 1);
1676 hashstr1[32] = '\0';
1679 av_md5_update(md5, method, strlen(method));
1680 av_md5_update(md5, ":/", 2);
1681 av_md5_update(md5, rt->app, strlen(rt->app));
1682 if (!strchr(rt->app, '/'))
1683 av_md5_update(md5, "/_definst_", strlen("/_definst_"));
1684 av_md5_final(md5, hash);
1685 ff_data_to_hex(hashstr2, hash, 16, 1);
1686 hashstr2[32] = '\0';
1689 av_md5_update(md5, hashstr1, strlen(hashstr1));
1690 av_md5_update(md5, ":", 1);
1692 av_md5_update(md5, nonce, strlen(nonce));
1693 av_md5_update(md5, ":", 1);
1694 av_md5_update(md5, nc, strlen(nc));
1695 av_md5_update(md5, ":", 1);
1696 av_md5_update(md5, cnonce, strlen(cnonce));
1697 av_md5_update(md5, ":", 1);
1698 av_md5_update(md5, qop, strlen(qop));
1699 av_md5_update(md5, ":", 1);
1700 av_md5_update(md5, hashstr2, strlen(hashstr2));
1701 av_md5_final(md5, hash);
1702 ff_data_to_hex(hashstr1, hash, 16, 1);
1704 snprintf(rt->auth_params, sizeof(rt->auth_params),
1705 "?authmod=%s&user=%s&nonce=%s&cnonce=%s&nc=%s&response=%s",
1706 "llnw", user, nonce, cnonce, nc, hashstr1);
1712 static int handle_connect_error(URLContext *s, const char *desc)
1714 RTMPContext *rt = s->priv_data;
1715 char buf[300], *ptr, authmod[15];
1717 const char *user = "", *salt = "", *opaque = NULL,
1718 *challenge = NULL, *cptr = NULL, *nonce = NULL;
1720 if (!(cptr = strstr(desc, "authmod=adobe")) &&
1721 !(cptr = strstr(desc, "authmod=llnw"))) {
1722 av_log(s, AV_LOG_ERROR,
1723 "Unknown connect error (unsupported authentication method?)\n");
1724 return AVERROR_UNKNOWN;
1726 cptr += strlen("authmod=");
1727 while (*cptr && *cptr != ' ' && i < sizeof(authmod) - 1)
1728 authmod[i++] = *cptr++;
1731 if (!rt->username[0] || !rt->password[0]) {
1732 av_log(s, AV_LOG_ERROR, "No credentials set\n");
1733 return AVERROR_UNKNOWN;
1736 if (strstr(desc, "?reason=authfailed")) {
1737 av_log(s, AV_LOG_ERROR, "Incorrect username/password\n");
1738 return AVERROR_UNKNOWN;
1739 } else if (strstr(desc, "?reason=nosuchuser")) {
1740 av_log(s, AV_LOG_ERROR, "Incorrect username\n");
1741 return AVERROR_UNKNOWN;
1744 if (rt->auth_tried) {
1745 av_log(s, AV_LOG_ERROR, "Authentication failed\n");
1746 return AVERROR_UNKNOWN;
1749 rt->auth_params[0] = '\0';
1751 if (strstr(desc, "code=403 need auth")) {
1752 snprintf(rt->auth_params, sizeof(rt->auth_params),
1753 "?authmod=%s&user=%s", authmod, rt->username);
1757 if (!(cptr = strstr(desc, "?reason=needauth"))) {
1758 av_log(s, AV_LOG_ERROR, "No auth parameters found\n");
1759 return AVERROR_UNKNOWN;
1762 av_strlcpy(buf, cptr + 1, sizeof(buf));
1766 char *next = strchr(ptr, '&');
1767 char *value = strchr(ptr, '=');
1772 if (!strcmp(ptr, "user")) {
1774 } else if (!strcmp(ptr, "salt")) {
1776 } else if (!strcmp(ptr, "opaque")) {
1778 } else if (!strcmp(ptr, "challenge")) {
1780 } else if (!strcmp(ptr, "nonce")) {
1786 if (!strcmp(authmod, "adobe")) {
1787 if ((ret = do_adobe_auth(rt, user, salt, opaque, challenge)) < 0)
1790 if ((ret = do_llnw_auth(rt, user, nonce)) < 0)
1798 static int handle_invoke_error(URLContext *s, RTMPPacket *pkt)
1800 RTMPContext *rt = s->priv_data;
1801 const uint8_t *data_end = pkt->data + pkt->size;
1802 char *tracked_method = NULL;
1803 int level = AV_LOG_ERROR;
1804 uint8_t tmpstr[256];
1807 if ((ret = find_tracked_method(s, pkt, 9, &tracked_method)) < 0)
1810 if (!ff_amf_get_field_value(pkt->data + 9, data_end,
1811 "description", tmpstr, sizeof(tmpstr))) {
1812 if (tracked_method && (!strcmp(tracked_method, "_checkbw") ||
1813 !strcmp(tracked_method, "releaseStream") ||
1814 !strcmp(tracked_method, "FCSubscribe") ||
1815 !strcmp(tracked_method, "FCPublish"))) {
1816 /* Gracefully ignore Adobe-specific historical artifact errors. */
1817 level = AV_LOG_WARNING;
1819 } else if (tracked_method && !strcmp(tracked_method, "getStreamLength")) {
1820 level = rt->live ? AV_LOG_DEBUG : AV_LOG_WARNING;
1822 } else if (tracked_method && !strcmp(tracked_method, "connect")) {
1823 ret = handle_connect_error(s, tmpstr);
1825 rt->do_reconnect = 1;
1826 level = AV_LOG_VERBOSE;
1829 ret = AVERROR_UNKNOWN;
1830 av_log(s, level, "Server error: %s\n", tmpstr);
1833 av_free(tracked_method);
1837 static int write_begin(URLContext *s)
1839 RTMPContext *rt = s->priv_data;
1841 RTMPPacket spkt = { 0 };
1844 // Send Stream Begin 1
1845 if ((ret = ff_rtmp_packet_create(&spkt, RTMP_NETWORK_CHANNEL,
1846 RTMP_PT_PING, 0, 6)) < 0) {
1847 av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1851 bytestream2_init_writer(&pbc, spkt.data, spkt.size);
1852 bytestream2_put_be16(&pbc, 0); // 0 -> Stream Begin
1853 bytestream2_put_be32(&pbc, rt->nb_streamid);
1855 ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1856 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
1858 ff_rtmp_packet_destroy(&spkt);
1863 static int write_status(URLContext *s, RTMPPacket *pkt,
1864 const char *status, const char *filename)
1866 RTMPContext *rt = s->priv_data;
1867 RTMPPacket spkt = { 0 };
1868 char statusmsg[128];
1872 if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1874 RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1875 av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1880 spkt.extra = pkt->extra;
1881 ff_amf_write_string(&pp, "onStatus");
1882 ff_amf_write_number(&pp, 0);
1883 ff_amf_write_null(&pp);
1885 ff_amf_write_object_start(&pp);
1886 ff_amf_write_field_name(&pp, "level");
1887 ff_amf_write_string(&pp, "status");
1888 ff_amf_write_field_name(&pp, "code");
1889 ff_amf_write_string(&pp, status);
1890 ff_amf_write_field_name(&pp, "description");
1891 snprintf(statusmsg, sizeof(statusmsg),
1892 "%s is now published", filename);
1893 ff_amf_write_string(&pp, statusmsg);
1894 ff_amf_write_field_name(&pp, "details");
1895 ff_amf_write_string(&pp, filename);
1896 ff_amf_write_field_name(&pp, "clientid");
1897 snprintf(statusmsg, sizeof(statusmsg), "%s", LIBAVFORMAT_IDENT);
1898 ff_amf_write_string(&pp, statusmsg);
1899 ff_amf_write_object_end(&pp);
1901 spkt.size = pp - spkt.data;
1902 ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1903 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
1904 ff_rtmp_packet_destroy(&spkt);
1909 static int send_invoke_response(URLContext *s, RTMPPacket *pkt)
1911 RTMPContext *rt = s->priv_data;
1917 const uint8_t *p = pkt->data;
1919 RTMPPacket spkt = { 0 };
1923 bytestream2_init(&gbc, p, pkt->size);
1924 if (ff_amf_read_string(&gbc, command, sizeof(command),
1926 av_log(s, AV_LOG_ERROR, "Error in PT_INVOKE\n");
1927 return AVERROR_INVALIDDATA;
1930 ret = ff_amf_read_number(&gbc, &seqnum);
1933 ret = ff_amf_read_null(&gbc);
1936 if (!strcmp(command, "FCPublish") ||
1937 !strcmp(command, "publish")) {
1938 ret = ff_amf_read_string(&gbc, filename,
1939 sizeof(filename), &stringlen);
1942 pchar = strrchr(s->filename, '/');
1944 av_log(s, AV_LOG_WARNING,
1945 "Unable to find / in url %s, bad format\n",
1947 pchar = s->filename;
1950 if (strcmp(pchar, filename))
1951 av_log(s, AV_LOG_WARNING, "Unexpected stream %s, expecting"
1952 " %s\n", filename, pchar);
1954 rt->state = STATE_RECEIVING;
1957 if (!strcmp(command, "FCPublish")) {
1958 if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1960 RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1961 av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1965 ff_amf_write_string(&pp, "onFCPublish");
1966 } else if (!strcmp(command, "publish")) {
1967 ret = write_begin(s);
1971 // Send onStatus(NetStream.Publish.Start)
1972 return write_status(s, pkt, "NetStream.Publish.Start",
1974 } else if (!strcmp(command, "play")) {
1975 ret = write_begin(s);
1978 rt->state = STATE_SENDING;
1979 return write_status(s, pkt, "NetStream.Play.Start",
1982 if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1984 RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1985 av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1989 ff_amf_write_string(&pp, "_result");
1990 ff_amf_write_number(&pp, seqnum);
1991 ff_amf_write_null(&pp);
1992 if (!strcmp(command, "createStream")) {
1994 if (rt->nb_streamid == 0 || rt->nb_streamid == 2)
1995 rt->nb_streamid++; /* Values 0 and 2 are reserved */
1996 ff_amf_write_number(&pp, rt->nb_streamid);
1997 /* By now we don't control which streams are removed in
1998 * deleteStream. There is no stream creation control
1999 * if a client creates more than 2^32 - 2 streams. */
2002 spkt.size = pp - spkt.data;
2003 ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
2004 &rt->prev_pkt[1], &rt->nb_prev_pkt[1]);
2005 ff_rtmp_packet_destroy(&spkt);
2010 * Read the AMF_NUMBER response ("_result") to a function call
2011 * (e.g. createStream()). This response should be made up of the AMF_STRING
2012 * "result", a NULL object and then the response encoded as AMF_NUMBER. On a
2013 * successful response, we will return set the value to number (otherwise number
2014 * will not be changed).
2016 * @return 0 if reading the value succeeds, negative value otherwiss
2018 static int read_number_result(RTMPPacket *pkt, double *number)
2020 // We only need to fit "_result" in this.
2021 uint8_t strbuffer[8];
2026 bytestream2_init(&gbc, pkt->data, pkt->size);
2028 // Value 1/4: "_result" as AMF_STRING
2029 if (ff_amf_read_string(&gbc, strbuffer, sizeof(strbuffer), &stringlen))
2030 return AVERROR_INVALIDDATA;
2031 if (strcmp(strbuffer, "_result"))
2032 return AVERROR_INVALIDDATA;
2033 // Value 2/4: The callee reference number
2034 if (ff_amf_read_number(&gbc, &numbuffer))
2035 return AVERROR_INVALIDDATA;
2037 if (ff_amf_read_null(&gbc))
2038 return AVERROR_INVALIDDATA;
2039 // Value 4/4: The resonse as AMF_NUMBER
2040 if (ff_amf_read_number(&gbc, &numbuffer))
2041 return AVERROR_INVALIDDATA;
2043 *number = numbuffer;
2048 static int handle_invoke_result(URLContext *s, RTMPPacket *pkt)
2050 RTMPContext *rt = s->priv_data;
2051 char *tracked_method = NULL;
2054 if ((ret = find_tracked_method(s, pkt, 10, &tracked_method)) < 0)
2057 if (!tracked_method) {
2058 /* Ignore this reply when the current method is not tracked. */
2062 if (!strcmp(tracked_method, "connect")) {
2063 if (!rt->is_input) {
2064 if ((ret = gen_release_stream(s, rt)) < 0)
2067 if ((ret = gen_fcpublish_stream(s, rt)) < 0)
2070 if ((ret = gen_server_bw(s, rt)) < 0)
2074 if ((ret = gen_create_stream(s, rt)) < 0)
2078 /* Send the FCSubscribe command when the name of live
2079 * stream is defined by the user or if it's a live stream. */
2080 if (rt->subscribe) {
2081 if ((ret = gen_fcsubscribe_stream(s, rt, rt->subscribe)) < 0)
2083 } else if (rt->live == -1) {
2084 if ((ret = gen_fcsubscribe_stream(s, rt, rt->playpath)) < 0)
2088 } else if (!strcmp(tracked_method, "createStream")) {
2090 if (read_number_result(pkt, &stream_id)) {
2091 av_log(s, AV_LOG_WARNING, "Unexpected reply on connect()\n");
2093 rt->stream_id = stream_id;
2096 if (!rt->is_input) {
2097 if ((ret = gen_publish(s, rt)) < 0)
2100 if (rt->live != -1) {
2101 if ((ret = gen_get_stream_length(s, rt)) < 0)
2104 if ((ret = gen_play(s, rt)) < 0)
2106 if ((ret = gen_buffer_time(s, rt)) < 0)
2109 } else if (!strcmp(tracked_method, "getStreamLength")) {
2110 if (read_number_result(pkt, &rt->duration)) {
2111 av_log(s, AV_LOG_WARNING, "Unexpected reply on getStreamLength()\n");
2116 av_free(tracked_method);
2120 static int handle_invoke_status(URLContext *s, RTMPPacket *pkt)
2122 RTMPContext *rt = s->priv_data;
2123 const uint8_t *data_end = pkt->data + pkt->size;
2124 const uint8_t *ptr = pkt->data + RTMP_HEADER;
2125 uint8_t tmpstr[256];
2128 for (i = 0; i < 2; i++) {
2129 t = ff_amf_tag_size(ptr, data_end);
2135 t = ff_amf_get_field_value(ptr, data_end, "level", tmpstr, sizeof(tmpstr));
2136 if (!t && !strcmp(tmpstr, "error")) {
2137 t = ff_amf_get_field_value(ptr, data_end,
2138 "description", tmpstr, sizeof(tmpstr));
2139 if (t || !tmpstr[0])
2140 t = ff_amf_get_field_value(ptr, data_end, "code",
2141 tmpstr, sizeof(tmpstr));
2143 av_log(s, AV_LOG_ERROR, "Server error: %s\n", tmpstr);
2147 t = ff_amf_get_field_value(ptr, data_end, "code", tmpstr, sizeof(tmpstr));
2148 if (!t && !strcmp(tmpstr, "NetStream.Play.Start")) rt->state = STATE_PLAYING;
2149 if (!t && !strcmp(tmpstr, "NetStream.Play.Stop")) rt->state = STATE_STOPPED;
2150 if (!t && !strcmp(tmpstr, "NetStream.Play.UnpublishNotify")) rt->state = STATE_STOPPED;
2151 if (!t && !strcmp(tmpstr, "NetStream.Publish.Start")) rt->state = STATE_PUBLISHING;
2152 if (!t && !strcmp(tmpstr, "NetStream.Seek.Notify")) rt->state = STATE_PLAYING;
2157 static int handle_invoke(URLContext *s, RTMPPacket *pkt)
2159 RTMPContext *rt = s->priv_data;
2162 //TODO: check for the messages sent for wrong state?
2163 if (ff_amf_match_string(pkt->data, pkt->size, "_error")) {
2164 if ((ret = handle_invoke_error(s, pkt)) < 0)
2166 } else if (ff_amf_match_string(pkt->data, pkt->size, "_result")) {
2167 if ((ret = handle_invoke_result(s, pkt)) < 0)
2169 } else if (ff_amf_match_string(pkt->data, pkt->size, "onStatus")) {
2170 if ((ret = handle_invoke_status(s, pkt)) < 0)
2172 } else if (ff_amf_match_string(pkt->data, pkt->size, "onBWDone")) {
2173 if ((ret = gen_check_bw(s, rt)) < 0)
2175 } else if (ff_amf_match_string(pkt->data, pkt->size, "releaseStream") ||
2176 ff_amf_match_string(pkt->data, pkt->size, "FCPublish") ||
2177 ff_amf_match_string(pkt->data, pkt->size, "publish") ||
2178 ff_amf_match_string(pkt->data, pkt->size, "play") ||
2179 ff_amf_match_string(pkt->data, pkt->size, "_checkbw") ||
2180 ff_amf_match_string(pkt->data, pkt->size, "createStream")) {
2181 if ((ret = send_invoke_response(s, pkt)) < 0)
2188 static int update_offset(RTMPContext *rt, int size)
2192 // generate packet header and put data into buffer for FLV demuxer
2193 if (rt->flv_off < rt->flv_size) {
2194 // There is old unread data in the buffer, thus append at the end
2195 old_flv_size = rt->flv_size;
2196 rt->flv_size += size;
2198 // All data has been read, write the new data at the start of the buffer
2200 rt->flv_size = size;
2204 return old_flv_size;
2207 static int append_flv_data(RTMPContext *rt, RTMPPacket *pkt, int skip)
2209 int old_flv_size, ret;
2211 const uint8_t *data = pkt->data + skip;
2212 const int size = pkt->size - skip;
2213 uint32_t ts = pkt->timestamp;
2215 if (pkt->type == RTMP_PT_AUDIO) {
2217 } else if (pkt->type == RTMP_PT_VIDEO) {
2221 old_flv_size = update_offset(rt, size + 15);
2223 if ((ret = av_reallocp(&rt->flv_data, rt->flv_size)) < 0) {
2224 rt->flv_size = rt->flv_off = 0;
2227 bytestream2_init_writer(&pbc, rt->flv_data, rt->flv_size);
2228 bytestream2_skip_p(&pbc, old_flv_size);
2229 bytestream2_put_byte(&pbc, pkt->type);
2230 bytestream2_put_be24(&pbc, size);
2231 bytestream2_put_be24(&pbc, ts);
2232 bytestream2_put_byte(&pbc, ts >> 24);
2233 bytestream2_put_be24(&pbc, 0);
2234 bytestream2_put_buffer(&pbc, data, size);
2235 bytestream2_put_be32(&pbc, 0);
2240 static int handle_notify(URLContext *s, RTMPPacket *pkt)
2242 RTMPContext *rt = s->priv_data;
2243 uint8_t commandbuffer[64];
2244 char statusmsg[128];
2245 int stringlen, ret, skip = 0;
2248 bytestream2_init(&gbc, pkt->data, pkt->size);
2249 if (ff_amf_read_string(&gbc, commandbuffer, sizeof(commandbuffer),
2251 return AVERROR_INVALIDDATA;
2253 if (!strcmp(commandbuffer, "onMetaData")) {
2254 // metadata properties should be stored in a mixed array
2255 if (bytestream2_get_byte(&gbc) == AMF_DATA_TYPE_MIXEDARRAY) {
2256 // We have found a metaData Array so flv can determine the streams
2258 rt->received_metadata = 1;
2259 // skip 32-bit max array index
2260 bytestream2_skip(&gbc, 4);
2261 while (bytestream2_get_bytes_left(&gbc) > 3) {
2262 if (ff_amf_get_string(&gbc, statusmsg, sizeof(statusmsg),
2264 return AVERROR_INVALIDDATA;
2265 // We do not care about the content of the property (yet).
2266 stringlen = ff_amf_tag_size(gbc.buffer, gbc.buffer_end);
2268 return AVERROR_INVALIDDATA;
2269 bytestream2_skip(&gbc, stringlen);
2271 // The presence of the following properties indicates that the
2272 // respective streams are present.
2273 if (!strcmp(statusmsg, "videocodecid")) {
2276 if (!strcmp(statusmsg, "audiocodecid")) {
2280 if (bytestream2_get_be24(&gbc) != AMF_END_OF_OBJECT)
2281 return AVERROR_INVALIDDATA;
2285 // Skip the @setDataFrame string and validate it is a notification
2286 if (!strcmp(commandbuffer, "@setDataFrame")) {
2287 skip = gbc.buffer - pkt->data;
2288 ret = ff_amf_read_string(&gbc, statusmsg,
2289 sizeof(statusmsg), &stringlen);
2291 return AVERROR_INVALIDDATA;
2294 return append_flv_data(rt, pkt, skip);
2298 * Parse received packet and possibly perform some action depending on
2299 * the packet contents.
2300 * @return 0 for no errors, negative values for serious errors which prevent
2301 * further communications, positive values for uncritical errors
2303 static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
2308 ff_rtmp_packet_dump(s, pkt);
2311 switch (pkt->type) {
2312 case RTMP_PT_BYTES_READ:
2313 av_dlog(s, "received bytes read report\n");
2315 case RTMP_PT_CHUNK_SIZE:
2316 if ((ret = handle_chunk_size(s, pkt)) < 0)
2320 if ((ret = handle_ping(s, pkt)) < 0)
2323 case RTMP_PT_CLIENT_BW:
2324 if ((ret = handle_client_bw(s, pkt)) < 0)
2327 case RTMP_PT_SERVER_BW:
2328 if ((ret = handle_server_bw(s, pkt)) < 0)
2331 case RTMP_PT_INVOKE:
2332 if ((ret = handle_invoke(s, pkt)) < 0)
2337 case RTMP_PT_METADATA:
2338 case RTMP_PT_NOTIFY:
2339 /* Audio, Video and Metadata packets are parsed in get_packet() */
2342 av_log(s, AV_LOG_VERBOSE, "Unknown packet type received 0x%02X\n", pkt->type);
2348 static int handle_metadata(RTMPContext *rt, RTMPPacket *pkt)
2350 int ret, old_flv_size, type;
2351 const uint8_t *next;
2354 uint32_t ts, cts, pts = 0;
2356 old_flv_size = update_offset(rt, pkt->size);
2358 if ((ret = av_reallocp(&rt->flv_data, rt->flv_size)) < 0) {
2359 rt->flv_size = rt->flv_off = 0;
2364 p = rt->flv_data + old_flv_size;
2366 /* copy data while rewriting timestamps */
2367 ts = pkt->timestamp;
2369 while (next - pkt->data < pkt->size - RTMP_HEADER) {
2370 type = bytestream_get_byte(&next);
2371 size = bytestream_get_be24(&next);
2372 cts = bytestream_get_be24(&next);
2373 cts |= bytestream_get_byte(&next) << 24;
2378 if (size + 3 + 4 > pkt->data + pkt->size - next)
2380 bytestream_put_byte(&p, type);
2381 bytestream_put_be24(&p, size);
2382 bytestream_put_be24(&p, ts);
2383 bytestream_put_byte(&p, ts >> 24);
2384 memcpy(p, next, size + 3 + 4);
2385 next += size + 3 + 4;
2388 if (p != rt->flv_data + rt->flv_size) {
2389 av_log(NULL, AV_LOG_WARNING, "Incomplete flv packets in "
2390 "RTMP_PT_METADATA packet\n");
2391 rt->flv_size = p - rt->flv_data;
2398 * Interact with the server by receiving and sending RTMP packets until
2399 * there is some significant data (media data or expected status notification).
2401 * @param s reading context
2402 * @param for_header non-zero value tells function to work until it
2403 * gets notification from the server that playing has been started,
2404 * otherwise function will work until some media data is received (or
2406 * @return 0 for successful operation, negative value in case of error
2408 static int get_packet(URLContext *s, int for_header)
2410 RTMPContext *rt = s->priv_data;
2413 if (rt->state == STATE_STOPPED)
2417 RTMPPacket rpkt = { 0 };
2418 if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
2419 rt->in_chunk_size, &rt->prev_pkt[0],
2420 &rt->nb_prev_pkt[0])) <= 0) {
2422 return AVERROR(EAGAIN);
2424 return AVERROR(EIO);
2428 // Track timestamp for later use
2429 rt->last_timestamp = rpkt.timestamp;
2431 rt->bytes_read += ret;
2432 if (rt->bytes_read > rt->last_bytes_read + rt->client_report_size) {
2433 av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
2434 if ((ret = gen_bytes_read(s, rt, rpkt.timestamp + 1)) < 0)
2436 rt->last_bytes_read = rt->bytes_read;
2439 ret = rtmp_parse_result(s, rt, &rpkt);
2441 // At this point we must check if we are in the seek state and continue
2442 // with the next packet. handle_invoke will get us out of this state
2443 // when the right message is encountered
2444 if (rt->state == STATE_SEEKING) {
2445 ff_rtmp_packet_destroy(&rpkt);
2446 // We continue, let the natural flow of things happen:
2447 // AVERROR(EAGAIN) or handle_invoke gets us out of here
2451 if (ret < 0) {//serious error in current packet
2452 ff_rtmp_packet_destroy(&rpkt);
2455 if (rt->do_reconnect && for_header) {
2456 ff_rtmp_packet_destroy(&rpkt);
2459 if (rt->state == STATE_STOPPED) {
2460 ff_rtmp_packet_destroy(&rpkt);
2463 if (for_header && (rt->state == STATE_PLAYING ||
2464 rt->state == STATE_PUBLISHING ||
2465 rt->state == STATE_SENDING ||
2466 rt->state == STATE_RECEIVING)) {
2467 ff_rtmp_packet_destroy(&rpkt);
2470 if (!rpkt.size || !rt->is_input) {
2471 ff_rtmp_packet_destroy(&rpkt);
2474 if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO) {
2475 ret = append_flv_data(rt, &rpkt, 0);
2476 ff_rtmp_packet_destroy(&rpkt);
2478 } else if (rpkt.type == RTMP_PT_NOTIFY) {
2479 ret = handle_notify(s, &rpkt);
2480 ff_rtmp_packet_destroy(&rpkt);
2482 } else if (rpkt.type == RTMP_PT_METADATA) {
2483 ret = handle_metadata(rt, &rpkt);
2484 ff_rtmp_packet_destroy(&rpkt);
2487 ff_rtmp_packet_destroy(&rpkt);
2491 static int rtmp_close(URLContext *h)
2493 RTMPContext *rt = h->priv_data;
2496 if (!rt->is_input) {
2497 rt->flv_data = NULL;
2498 if (rt->out_pkt.size)
2499 ff_rtmp_packet_destroy(&rt->out_pkt);
2500 if (rt->state > STATE_FCPUBLISH)
2501 ret = gen_fcunpublish_stream(h, rt);
2503 if (rt->state > STATE_HANDSHAKED)
2504 ret = gen_delete_stream(h, rt);
2505 for (i = 0; i < 2; i++) {
2506 for (j = 0; j < rt->nb_prev_pkt[i]; j++)
2507 ff_rtmp_packet_destroy(&rt->prev_pkt[i][j]);
2508 av_freep(&rt->prev_pkt[i]);
2511 free_tracked_methods(rt);
2512 av_freep(&rt->flv_data);
2513 ffurl_close(rt->stream);
2518 * Insert a fake onMetadata packet into the FLV stream to notify the FLV
2519 * demuxer about the duration of the stream.
2521 * This should only be done if there was no real onMetadata packet sent by the
2522 * server at the start of the stream and if we were able to retrieve a valid
2523 * duration via a getStreamLength call.
2525 * @return 0 for successful operation, negative value in case of error
2527 static int inject_fake_duration_metadata(RTMPContext *rt)
2529 // We need to insert the metdata packet directly after the FLV
2530 // header, i.e. we need to move all other already read data by the
2531 // size of our fake metadata packet.
2534 // Keep old flv_data pointer
2535 uint8_t* old_flv_data = rt->flv_data;
2536 // Allocate a new flv_data pointer with enough space for the additional package
2537 if (!(rt->flv_data = av_malloc(rt->flv_size + 55))) {
2538 rt->flv_data = old_flv_data;
2539 return AVERROR(ENOMEM);
2543 memcpy(rt->flv_data, old_flv_data, 13);
2544 // Copy remaining packets
2545 memcpy(rt->flv_data + 13 + 55, old_flv_data + 13, rt->flv_size - 13);
2546 // Increase the size by the injected packet
2548 // Delete the old FLV data
2549 av_free(old_flv_data);
2551 p = rt->flv_data + 13;
2552 bytestream_put_byte(&p, FLV_TAG_TYPE_META);
2553 bytestream_put_be24(&p, 40); // size of data part (sum of all parts below)
2554 bytestream_put_be24(&p, 0); // timestamp
2555 bytestream_put_be32(&p, 0); // reserved
2557 // first event name as a string
2558 bytestream_put_byte(&p, AMF_DATA_TYPE_STRING);
2559 // "onMetaData" as AMF string
2560 bytestream_put_be16(&p, 10);
2561 bytestream_put_buffer(&p, "onMetaData", 10);
2563 // mixed array (hash) with size and string/type/data tuples
2564 bytestream_put_byte(&p, AMF_DATA_TYPE_MIXEDARRAY);
2565 bytestream_put_be32(&p, 1); // metadata_count
2567 // "duration" as AMF string
2568 bytestream_put_be16(&p, 8);
2569 bytestream_put_buffer(&p, "duration", 8);
2570 bytestream_put_byte(&p, AMF_DATA_TYPE_NUMBER);
2571 bytestream_put_be64(&p, av_double2int(rt->duration));
2574 bytestream_put_be16(&p, 0); // Empty string
2575 bytestream_put_byte(&p, AMF_END_OF_OBJECT);
2576 bytestream_put_be32(&p, 40); // size of data part (sum of all parts below)
2582 * Open RTMP connection and verify that the stream can be played.
2584 * URL syntax: rtmp://server[:port][/app][/playpath]
2585 * where 'app' is first one or two directories in the path
2586 * (e.g. /ondemand/, /flash/live/, etc.)
2587 * and 'playpath' is a file name (the rest of the path,
2588 * may be prefixed with "mp4:")
2590 static int rtmp_open(URLContext *s, const char *uri, int flags)
2592 RTMPContext *rt = s->priv_data;
2593 char proto[8], hostname[256], path[1024], auth[100], *fname;
2594 char *old_app, *qmark, fname_buffer[1024];
2597 AVDictionary *opts = NULL;
2600 if (rt->listen_timeout > 0)
2603 rt->is_input = !(flags & AVIO_FLAG_WRITE);
2605 av_url_split(proto, sizeof(proto), auth, sizeof(auth),
2606 hostname, sizeof(hostname), &port,
2607 path, sizeof(path), s->filename);
2609 if (strchr(path, ' ')) {
2610 av_log(s, AV_LOG_WARNING,
2611 "Detected librtmp style URL parameters, these aren't supported "
2612 "by the libavformat internal RTMP handler currently enabled. "
2613 "See the documentation for the correct way to pass parameters.\n");
2617 char *ptr = strchr(auth, ':');
2620 av_strlcpy(rt->username, auth, sizeof(rt->username));
2621 av_strlcpy(rt->password, ptr + 1, sizeof(rt->password));
2625 if (rt->listen && strcmp(proto, "rtmp")) {
2626 av_log(s, AV_LOG_ERROR, "rtmp_listen not available for %s\n",
2628 return AVERROR(EINVAL);
2630 if (!strcmp(proto, "rtmpt") || !strcmp(proto, "rtmpts")) {
2631 if (!strcmp(proto, "rtmpts"))
2632 av_dict_set(&opts, "ffrtmphttp_tls", "1", 1);
2634 /* open the http tunneling connection */
2635 ff_url_join(buf, sizeof(buf), "ffrtmphttp", NULL, hostname, port, NULL);
2636 } else if (!strcmp(proto, "rtmps")) {
2637 /* open the tls connection */
2639 port = RTMPS_DEFAULT_PORT;
2640 ff_url_join(buf, sizeof(buf), "tls", NULL, hostname, port, NULL);
2641 } else if (!strcmp(proto, "rtmpe") || (!strcmp(proto, "rtmpte"))) {
2642 if (!strcmp(proto, "rtmpte"))
2643 av_dict_set(&opts, "ffrtmpcrypt_tunneling", "1", 1);
2645 /* open the encrypted connection */
2646 ff_url_join(buf, sizeof(buf), "ffrtmpcrypt", NULL, hostname, port, NULL);
2649 /* open the tcp connection */
2651 port = RTMP_DEFAULT_PORT;
2653 ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port,
2654 "?listen&listen_timeout=%d",
2655 rt->listen_timeout * 1000);
2657 ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
2661 if ((ret = ffurl_open(&rt->stream, buf, AVIO_FLAG_READ_WRITE,
2662 &s->interrupt_callback, &opts)) < 0) {
2663 av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf);
2667 if (rt->swfverify) {
2668 if ((ret = rtmp_calc_swfhash(s)) < 0)
2672 rt->state = STATE_START;
2673 if (!rt->listen && (ret = rtmp_handshake(s, rt)) < 0)
2675 if (rt->listen && (ret = rtmp_server_handshake(s, rt)) < 0)
2678 rt->out_chunk_size = 128;
2679 rt->in_chunk_size = 128; // Probably overwritten later
2680 rt->state = STATE_HANDSHAKED;
2682 // Keep the application name when it has been defined by the user.
2685 rt->app = av_malloc(APP_MAX_LENGTH);
2687 ret = AVERROR(ENOMEM);
2691 //extract "app" part from path
2692 qmark = strchr(path, '?');
2693 if (qmark && strstr(qmark, "slist=")) {
2695 // After slist we have the playpath, before the params, the app
2696 av_strlcpy(rt->app, path + 1, FFMIN(qmark - path, APP_MAX_LENGTH));
2697 fname = strstr(path, "slist=") + 6;
2698 // Strip any further query parameters from fname
2699 amp = strchr(fname, '&');
2701 av_strlcpy(fname_buffer, fname, FFMIN(amp - fname + 1,
2702 sizeof(fname_buffer)));
2703 fname = fname_buffer;
2705 } else if (!strncmp(path, "/ondemand/", 10)) {
2707 memcpy(rt->app, "ondemand", 9);
2709 char *next = *path ? path + 1 : path;
2710 char *p = strchr(next, '/');
2715 // make sure we do not mismatch a playpath for an application instance
2716 char *c = strchr(p + 1, ':');
2717 fname = strchr(p + 1, '/');
2718 if (!fname || (c && c < fname)) {
2720 av_strlcpy(rt->app, path + 1, FFMIN(p - path, APP_MAX_LENGTH));
2723 av_strlcpy(rt->app, path + 1, FFMIN(fname - path - 1, APP_MAX_LENGTH));
2729 // The name of application has been defined by the user, override it.
2734 if (!rt->playpath) {
2735 int len = strlen(fname);
2737 rt->playpath = av_malloc(PLAYPATH_MAX_LENGTH);
2738 if (!rt->playpath) {
2739 ret = AVERROR(ENOMEM);
2743 if (!strchr(fname, ':') && len >= 4 &&
2744 (!strcmp(fname + len - 4, ".f4v") ||
2745 !strcmp(fname + len - 4, ".mp4"))) {
2746 memcpy(rt->playpath, "mp4:", 5);
2748 if (len >= 4 && !strcmp(fname + len - 4, ".flv"))
2749 fname[len - 4] = '\0';
2750 rt->playpath[0] = 0;
2752 av_strlcat(rt->playpath, fname, PLAYPATH_MAX_LENGTH);
2756 rt->tcurl = av_malloc(TCURL_MAX_LENGTH);
2758 ret = AVERROR(ENOMEM);
2761 ff_url_join(rt->tcurl, TCURL_MAX_LENGTH, proto, NULL, hostname,
2762 port, "/%s", rt->app);
2765 if (!rt->flashver) {
2766 rt->flashver = av_malloc(FLASHVER_MAX_LENGTH);
2767 if (!rt->flashver) {
2768 ret = AVERROR(ENOMEM);
2772 snprintf(rt->flashver, FLASHVER_MAX_LENGTH, "%s %d,%d,%d,%d",
2773 RTMP_CLIENT_PLATFORM, RTMP_CLIENT_VER1, RTMP_CLIENT_VER2,
2774 RTMP_CLIENT_VER3, RTMP_CLIENT_VER4);
2776 snprintf(rt->flashver, FLASHVER_MAX_LENGTH,
2777 "FMLE/3.0 (compatible; %s)", LIBAVFORMAT_IDENT);
2781 rt->client_report_size = 1048576;
2785 rt->received_metadata = 0;
2786 rt->last_bytes_read = 0;
2787 rt->server_bw = 2500000;
2790 av_log(s, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
2791 proto, path, rt->app, rt->playpath);
2793 if ((ret = gen_connect(s, rt)) < 0)
2796 if ((ret = read_connect(s, s->priv_data)) < 0)
2801 ret = get_packet(s, 1);
2802 } while (ret == AVERROR(EAGAIN));
2806 if (rt->do_reconnect) {
2808 ffurl_close(rt->stream);
2810 rt->do_reconnect = 0;
2812 for (i = 0; i < 2; i++)
2813 memset(rt->prev_pkt[i], 0,
2814 sizeof(**rt->prev_pkt) * rt->nb_prev_pkt[i]);
2815 free_tracked_methods(rt);
2820 // generate FLV header for demuxer
2822 if ((ret = av_reallocp(&rt->flv_data, rt->flv_size)) < 0)
2825 memcpy(rt->flv_data, "FLV\1\0\0\0\0\011\0\0\0\0", rt->flv_size);
2827 // Read packets until we reach the first A/V packet or read metadata.
2828 // If there was a metadata package in front of the A/V packets, we can
2829 // build the FLV header from this. If we do not receive any metadata,
2830 // the FLV decoder will allocate the needed streams when their first
2831 // audio or video packet arrives.
2832 while (!rt->has_audio && !rt->has_video && !rt->received_metadata) {
2833 if ((ret = get_packet(s, 0)) < 0)
2837 // Either after we have read the metadata or (if there is none) the
2838 // first packet of an A/V stream, we have a better knowledge about the
2839 // streams, so set the FLV header accordingly.
2840 if (rt->has_audio) {
2841 rt->flv_data[4] |= FLV_HEADER_FLAG_HASAUDIO;
2843 if (rt->has_video) {
2844 rt->flv_data[4] |= FLV_HEADER_FLAG_HASVIDEO;
2847 // If we received the first packet of an A/V stream and no metadata but
2848 // the server returned a valid duration, create a fake metadata packet
2849 // to inform the FLV decoder about the duration.
2850 if (!rt->received_metadata && rt->duration > 0) {
2851 if ((ret = inject_fake_duration_metadata(rt)) < 0)
2856 rt->flv_data = NULL;
2858 rt->skip_bytes = 13;
2861 s->max_packet_size = rt->stream->max_packet_size;
2866 av_dict_free(&opts);
2871 static int rtmp_read(URLContext *s, uint8_t *buf, int size)
2873 RTMPContext *rt = s->priv_data;
2874 int orig_size = size;
2878 int data_left = rt->flv_size - rt->flv_off;
2880 if (data_left >= size) {
2881 memcpy(buf, rt->flv_data + rt->flv_off, size);
2882 rt->flv_off += size;
2885 if (data_left > 0) {
2886 memcpy(buf, rt->flv_data + rt->flv_off, data_left);
2889 rt->flv_off = rt->flv_size;
2892 if ((ret = get_packet(s, 0)) < 0)
2898 static int64_t rtmp_seek(URLContext *s, int stream_index, int64_t timestamp,
2901 RTMPContext *rt = s->priv_data;
2903 av_log(s, AV_LOG_DEBUG,
2904 "Seek on stream index %d at timestamp %"PRId64" with flags %08x\n",
2905 stream_index, timestamp, flags);
2906 if ((ret = gen_seek(s, rt, timestamp)) < 0) {
2907 av_log(s, AV_LOG_ERROR,
2908 "Unable to send seek command on stream index %d at timestamp "
2909 "%"PRId64" with flags %08x\n",
2910 stream_index, timestamp, flags);
2913 rt->flv_off = rt->flv_size;
2914 rt->state = STATE_SEEKING;
2918 static int rtmp_pause(URLContext *s, int pause)
2920 RTMPContext *rt = s->priv_data;
2922 av_log(s, AV_LOG_DEBUG, "Pause at timestamp %d\n",
2923 rt->last_timestamp);
2924 if ((ret = gen_pause(s, rt, pause, rt->last_timestamp)) < 0) {
2925 av_log(s, AV_LOG_ERROR, "Unable to send pause command at timestamp %d\n",
2926 rt->last_timestamp);
2932 static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
2934 RTMPContext *rt = s->priv_data;
2935 int size_temp = size;
2936 int pktsize, pkttype;
2938 const uint8_t *buf_temp = buf;
2943 if (rt->skip_bytes) {
2944 int skip = FFMIN(rt->skip_bytes, size_temp);
2947 rt->skip_bytes -= skip;
2951 if (rt->flv_header_bytes < RTMP_HEADER) {
2952 const uint8_t *header = rt->flv_header;
2953 int copy = FFMIN(RTMP_HEADER - rt->flv_header_bytes, size_temp);
2954 int channel = RTMP_AUDIO_CHANNEL;
2955 bytestream_get_buffer(&buf_temp, rt->flv_header + rt->flv_header_bytes, copy);
2956 rt->flv_header_bytes += copy;
2958 if (rt->flv_header_bytes < RTMP_HEADER)
2961 pkttype = bytestream_get_byte(&header);
2962 pktsize = bytestream_get_be24(&header);
2963 ts = bytestream_get_be24(&header);
2964 ts |= bytestream_get_byte(&header) << 24;
2965 bytestream_get_be24(&header);
2966 rt->flv_size = pktsize;
2968 if (pkttype == RTMP_PT_VIDEO)
2969 channel = RTMP_VIDEO_CHANNEL;
2971 //force 12bytes header
2972 if (((pkttype == RTMP_PT_VIDEO || pkttype == RTMP_PT_AUDIO) && ts == 0) ||
2973 pkttype == RTMP_PT_NOTIFY) {
2974 if (pkttype == RTMP_PT_NOTIFY)
2976 if ((ret = ff_rtmp_check_alloc_array(&rt->prev_pkt[1],
2977 &rt->nb_prev_pkt[1],
2980 rt->prev_pkt[1][channel].channel_id = 0;
2983 //this can be a big packet, it's better to send it right here
2984 if ((ret = ff_rtmp_packet_create(&rt->out_pkt, channel,
2985 pkttype, ts, pktsize)) < 0)
2988 rt->out_pkt.extra = rt->stream_id;
2989 rt->flv_data = rt->out_pkt.data;
2991 if (pkttype == RTMP_PT_NOTIFY)
2992 ff_amf_write_string(&rt->flv_data, "@setDataFrame");
2995 if (rt->flv_size - rt->flv_off > size_temp) {
2996 bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, size_temp);
2997 rt->flv_off += size_temp;
3000 bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);
3001 size_temp -= rt->flv_size - rt->flv_off;
3002 rt->flv_off += rt->flv_size - rt->flv_off;
3005 if (rt->flv_off == rt->flv_size) {
3008 if ((ret = rtmp_send_packet(rt, &rt->out_pkt, 0)) < 0)
3012 rt->flv_header_bytes = 0;
3013 rt->flv_nb_packets++;
3015 } while (buf_temp - buf < size);
3017 if (rt->flv_nb_packets < rt->flush_interval)
3019 rt->flv_nb_packets = 0;
3021 /* set stream into nonblocking mode */
3022 rt->stream->flags |= AVIO_FLAG_NONBLOCK;
3024 /* try to read one byte from the stream */
3025 ret = ffurl_read(rt->stream, &c, 1);
3027 /* switch the stream back into blocking mode */
3028 rt->stream->flags &= ~AVIO_FLAG_NONBLOCK;
3030 if (ret == AVERROR(EAGAIN)) {
3031 /* no incoming data to handle */
3033 } else if (ret < 0) {
3035 } else if (ret == 1) {
3036 RTMPPacket rpkt = { 0 };
3038 if ((ret = ff_rtmp_packet_read_internal(rt->stream, &rpkt,
3041 &rt->nb_prev_pkt[0], c)) <= 0)
3044 if ((ret = rtmp_parse_result(s, rt, &rpkt)) < 0)
3047 ff_rtmp_packet_destroy(&rpkt);
3053 #define OFFSET(x) offsetof(RTMPContext, x)
3054 #define DEC AV_OPT_FLAG_DECODING_PARAM
3055 #define ENC AV_OPT_FLAG_ENCODING_PARAM
3057 static const AVOption rtmp_options[] = {
3058 {"rtmp_app", "Name of application to connect to on the RTMP server", OFFSET(app), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
3059 {"rtmp_buffer", "Set buffer time in milliseconds. The default is 3000.", OFFSET(client_buffer_time), AV_OPT_TYPE_INT, {.i64 = 3000}, 0, INT_MAX, DEC|ENC},
3060 {"rtmp_conn", "Append arbitrary AMF data to the Connect message", OFFSET(conn), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
3061 {"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},
3062 {"rtmp_flush_interval", "Number of packets flushed in the same request (RTMPT only).", OFFSET(flush_interval), AV_OPT_TYPE_INT, {.i64 = 10}, 0, INT_MAX, ENC},
3063 {"rtmp_live", "Specify that the media is a live stream.", OFFSET(live), AV_OPT_TYPE_INT, {.i64 = -2}, INT_MIN, INT_MAX, DEC, "rtmp_live"},
3064 {"any", "both", 0, AV_OPT_TYPE_CONST, {.i64 = -2}, 0, 0, DEC, "rtmp_live"},
3065 {"live", "live stream", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, DEC, "rtmp_live"},
3066 {"recorded", "recorded stream", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, DEC, "rtmp_live"},
3067 {"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},
3068 {"rtmp_playpath", "Stream identifier to play or to publish", OFFSET(playpath), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
3069 {"rtmp_subscribe", "Name of live stream to subscribe to. Defaults to rtmp_playpath.", OFFSET(subscribe), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
3070 {"rtmp_swfhash", "SHA256 hash of the decompressed SWF file (32 bytes).", OFFSET(swfhash), AV_OPT_TYPE_BINARY, .flags = DEC},
3071 {"rtmp_swfsize", "Size of the decompressed SWF file, required for SWFVerification.", OFFSET(swfsize), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC},
3072 {"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},
3073 {"rtmp_swfverify", "URL to player swf file, compute hash/size automatically.", OFFSET(swfverify), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
3074 {"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},
3075 {"rtmp_listen", "Listen for incoming rtmp connections", OFFSET(listen), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
3076 {"listen", "Listen for incoming rtmp connections", OFFSET(listen), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
3077 {"timeout", "Maximum timeout (in seconds) to wait for incoming connections. -1 is infinite. Implies -rtmp_listen 1", OFFSET(listen_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
3081 #define RTMP_PROTOCOL(flavor) \
3082 static const AVClass flavor##_class = { \
3083 .class_name = #flavor, \
3084 .item_name = av_default_item_name, \
3085 .option = rtmp_options, \
3086 .version = LIBAVUTIL_VERSION_INT, \
3089 URLProtocol ff_##flavor##_protocol = { \
3091 .url_open = rtmp_open, \
3092 .url_read = rtmp_read, \
3093 .url_read_seek = rtmp_seek, \
3094 .url_read_pause = rtmp_pause, \
3095 .url_write = rtmp_write, \
3096 .url_close = rtmp_close, \
3097 .priv_data_size = sizeof(RTMPContext), \
3098 .flags = URL_PROTOCOL_FLAG_NETWORK, \
3099 .priv_data_class= &flavor##_class, \
3104 RTMP_PROTOCOL(rtmpe)
3105 RTMP_PROTOCOL(rtmps)
3106 RTMP_PROTOCOL(rtmpt)
3107 RTMP_PROTOCOL(rtmpte)
3108 RTMP_PROTOCOL(rtmpts)