urlprotocol: receive a list of protocols from the caller
[ffmpeg.git] / libavformat / sapenc.c
1 /*
2  * Session Announcement Protocol (RFC 2974) muxer
3  * Copyright (c) 2010 Martin Storsjo
4  *
5  * This file is part of Libav.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include "avformat.h"
23 #include "libavutil/parseutils.h"
24 #include "libavutil/random_seed.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/dict.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/time.h"
29 #include "internal.h"
30 #include "network.h"
31 #include "os_support.h"
32 #include "rtpenc_chain.h"
33 #include "url.h"
34
35 struct SAPState {
36     uint8_t    *ann;
37     int         ann_size;
38     URLContext *ann_fd;
39     int64_t     last_time;
40
41     const URLProtocol **protocols;
42 };
43
44 static int sap_write_close(AVFormatContext *s)
45 {
46     struct SAPState *sap = s->priv_data;
47     int i;
48
49     for (i = 0; i < s->nb_streams; i++) {
50         AVFormatContext *rtpctx = s->streams[i]->priv_data;
51         if (!rtpctx)
52             continue;
53         av_write_trailer(rtpctx);
54         avio_close(rtpctx->pb);
55         avformat_free_context(rtpctx);
56         s->streams[i]->priv_data = NULL;
57     }
58
59     if (sap->last_time && sap->ann && sap->ann_fd) {
60         sap->ann[0] |= 4; /* Session deletion*/
61         ffurl_write(sap->ann_fd, sap->ann, sap->ann_size);
62     }
63
64     av_freep(&sap->protocols);
65
66     av_freep(&sap->ann);
67     if (sap->ann_fd)
68         ffurl_close(sap->ann_fd);
69     ff_network_close();
70     return 0;
71 }
72
73 static int sap_write_header(AVFormatContext *s)
74 {
75     struct SAPState *sap = s->priv_data;
76     char host[1024], path[1024], url[1024], announce_addr[50] = "";
77     char *option_list;
78     int port = 9875, base_port = 5004, i, pos = 0, same_port = 0, ttl = 255;
79     AVFormatContext **contexts = NULL;
80     int ret = 0;
81     struct sockaddr_storage localaddr;
82     socklen_t addrlen = sizeof(localaddr);
83     int udp_fd;
84     AVDictionaryEntry* title = av_dict_get(s->metadata, "title", NULL, 0);
85
86     if (!ff_network_init())
87         return AVERROR(EIO);
88
89     /* extract hostname and port */
90     av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &base_port,
91                  path, sizeof(path), s->filename);
92     if (base_port < 0)
93         base_port = 5004;
94
95     /* search for options */
96     option_list = strrchr(path, '?');
97     if (option_list) {
98         char buf[50];
99         if (av_find_info_tag(buf, sizeof(buf), "announce_port", option_list)) {
100             port = strtol(buf, NULL, 10);
101         }
102         if (av_find_info_tag(buf, sizeof(buf), "same_port", option_list)) {
103             same_port = strtol(buf, NULL, 10);
104         }
105         if (av_find_info_tag(buf, sizeof(buf), "ttl", option_list)) {
106             ttl = strtol(buf, NULL, 10);
107         }
108         if (av_find_info_tag(buf, sizeof(buf), "announce_addr", option_list)) {
109             av_strlcpy(announce_addr, buf, sizeof(announce_addr));
110         }
111     }
112
113     if (!announce_addr[0]) {
114         struct addrinfo hints = { 0 }, *ai = NULL;
115         hints.ai_family = AF_UNSPEC;
116         if (getaddrinfo(host, NULL, &hints, &ai)) {
117             av_log(s, AV_LOG_ERROR, "Unable to resolve %s\n", host);
118             ret = AVERROR(EIO);
119             goto fail;
120         }
121         if (ai->ai_family == AF_INET) {
122             /* Also known as sap.mcast.net */
123             av_strlcpy(announce_addr, "224.2.127.254", sizeof(announce_addr));
124 #if HAVE_STRUCT_SOCKADDR_IN6
125         } else if (ai->ai_family == AF_INET6) {
126             /* With IPv6, you can use the same destination in many different
127              * multicast subnets, to choose how far you want it routed.
128              * This one is intended to be routed globally. */
129             av_strlcpy(announce_addr, "ff0e::2:7ffe", sizeof(announce_addr));
130 #endif
131         } else {
132             freeaddrinfo(ai);
133             av_log(s, AV_LOG_ERROR, "Host %s resolved to unsupported "
134                                     "address family\n", host);
135             ret = AVERROR(EIO);
136             goto fail;
137         }
138         freeaddrinfo(ai);
139     }
140
141     sap->protocols = ffurl_get_protocols(NULL, NULL);
142     if (!sap->protocols) {
143         ret = AVERROR(ENOMEM);
144         goto fail;
145     }
146
147     contexts = av_mallocz(sizeof(AVFormatContext*) * s->nb_streams);
148     if (!contexts) {
149         ret = AVERROR(ENOMEM);
150         goto fail;
151     }
152
153     s->start_time_realtime = av_gettime();
154     for (i = 0; i < s->nb_streams; i++) {
155         URLContext *fd;
156
157         ff_url_join(url, sizeof(url), "rtp", NULL, host, base_port,
158                     "?ttl=%d", ttl);
159         if (!same_port)
160             base_port += 2;
161         ret = ffurl_open(&fd, url, AVIO_FLAG_WRITE, &s->interrupt_callback, NULL,
162                          sap->protocols);
163         if (ret) {
164             ret = AVERROR(EIO);
165             goto fail;
166         }
167         ret = ff_rtp_chain_mux_open(&contexts[i], s, s->streams[i], fd, 0, i);
168         if (ret < 0)
169             goto fail;
170         s->streams[i]->priv_data = contexts[i];
171         s->streams[i]->time_base = contexts[i]->streams[0]->time_base;
172         av_strlcpy(contexts[i]->filename, url, sizeof(contexts[i]->filename));
173     }
174
175     if (s->nb_streams > 0 && title)
176         av_dict_set(&contexts[0]->metadata, "title", title->value, 0);
177
178     ff_url_join(url, sizeof(url), "udp", NULL, announce_addr, port,
179                 "?ttl=%d&connect=1", ttl);
180     ret = ffurl_open(&sap->ann_fd, url, AVIO_FLAG_WRITE,
181                      &s->interrupt_callback, NULL, sap->protocols);
182     if (ret) {
183         ret = AVERROR(EIO);
184         goto fail;
185     }
186
187     udp_fd = ffurl_get_file_handle(sap->ann_fd);
188     if (getsockname(udp_fd, (struct sockaddr*) &localaddr, &addrlen)) {
189         ret = AVERROR(EIO);
190         goto fail;
191     }
192     if (localaddr.ss_family != AF_INET
193 #if HAVE_STRUCT_SOCKADDR_IN6
194         && localaddr.ss_family != AF_INET6
195 #endif
196         ) {
197         av_log(s, AV_LOG_ERROR, "Unsupported protocol family\n");
198         ret = AVERROR(EIO);
199         goto fail;
200     }
201     sap->ann_size = 8192;
202     sap->ann = av_mallocz(sap->ann_size);
203     if (!sap->ann) {
204         ret = AVERROR(EIO);
205         goto fail;
206     }
207     sap->ann[pos] = (1 << 5);
208 #if HAVE_STRUCT_SOCKADDR_IN6
209     if (localaddr.ss_family == AF_INET6)
210         sap->ann[pos] |= 0x10;
211 #endif
212     pos++;
213     sap->ann[pos++] = 0; /* Authentication length */
214     AV_WB16(&sap->ann[pos], av_get_random_seed());
215     pos += 2;
216     if (localaddr.ss_family == AF_INET) {
217         memcpy(&sap->ann[pos], &((struct sockaddr_in*)&localaddr)->sin_addr,
218                sizeof(struct in_addr));
219         pos += sizeof(struct in_addr);
220 #if HAVE_STRUCT_SOCKADDR_IN6
221     } else {
222         memcpy(&sap->ann[pos], &((struct sockaddr_in6*)&localaddr)->sin6_addr,
223                sizeof(struct in6_addr));
224         pos += sizeof(struct in6_addr);
225 #endif
226     }
227
228     av_strlcpy(&sap->ann[pos], "application/sdp", sap->ann_size - pos);
229     pos += strlen(&sap->ann[pos]) + 1;
230
231     if (av_sdp_create(contexts, s->nb_streams, &sap->ann[pos],
232                       sap->ann_size - pos)) {
233         ret = AVERROR_INVALIDDATA;
234         goto fail;
235     }
236     av_freep(&contexts);
237     av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", &sap->ann[pos]);
238     pos += strlen(&sap->ann[pos]);
239     sap->ann_size = pos;
240
241     if (sap->ann_size > sap->ann_fd->max_packet_size) {
242         av_log(s, AV_LOG_ERROR, "Announcement too large to send in one "
243                                 "packet\n");
244         goto fail;
245     }
246
247     return 0;
248
249 fail:
250     av_free(contexts);
251     sap_write_close(s);
252     return ret;
253 }
254
255 static int sap_write_packet(AVFormatContext *s, AVPacket *pkt)
256 {
257     AVFormatContext *rtpctx;
258     struct SAPState *sap = s->priv_data;
259     int64_t now = av_gettime_relative();
260
261     if (!sap->last_time || now - sap->last_time > 5000000) {
262         int ret = ffurl_write(sap->ann_fd, sap->ann, sap->ann_size);
263         /* Don't abort even if we get "Destination unreachable" */
264         if (ret < 0 && ret != AVERROR(ECONNREFUSED))
265             return ret;
266         sap->last_time = now;
267     }
268     rtpctx = s->streams[pkt->stream_index]->priv_data;
269     return ff_write_chained(rtpctx, 0, pkt, s);
270 }
271
272 AVOutputFormat ff_sap_muxer = {
273     .name              = "sap",
274     .long_name         = NULL_IF_CONFIG_SMALL("SAP output"),
275     .priv_data_size    = sizeof(struct SAPState),
276     .audio_codec       = AV_CODEC_ID_AAC,
277     .video_codec       = AV_CODEC_ID_MPEG4,
278     .write_header      = sap_write_header,
279     .write_packet      = sap_write_packet,
280     .write_trailer     = sap_write_close,
281     .flags             = AVFMT_NOFILE | AVFMT_GLOBALHEADER,
282 };