Fill the buffer with 0 before writing an SDP in it
[ffmpeg.git] / libavformat / sdp.c
1 /*
2  * copyright (c) 2007 Luca Abeni
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "avstring.h"
22 #include "avformat.h"
23
24 #ifdef CONFIG_RTP_MUXER
25 #define MAX_EXTRADATA_SIZE ((INT_MAX - 10) / 2)
26
27 struct sdp_session_level {
28     int sdp_version;      /**< protocol version (currently 0) */
29     int id;               /**< session id */
30     int version;          /**< session version */
31     int start_time;       /**< session start time (NTP time, in seconds),
32                              or 0 in case of permanent session */
33     int end_time;         /**< session end time (NTP time, in seconds),
34                                or 0 if the session is not bounded */
35     int ttl;              /**< TTL, in case of multicast stream */
36     const char *user;     /**< username of the session's creator */
37     const char *src_addr; /**< IP address of the machine from which the session was created */
38     const char *dst_addr; /**< destination IP address (can be multicast) */
39     const char *name;     /**< session name (can be an empty string) */
40 };
41
42 static void dest_write(char *buff, int size, const char *dest_addr, int ttl)
43 {
44     if (dest_addr) {
45         if (ttl > 0) {
46             av_strlcatf(buff, size, "c=IN IP4 %s/%d\r\n", dest_addr, ttl);
47         } else {
48             av_strlcatf(buff, size, "c=IN IP4 %s\r\n", dest_addr);
49         }
50     }
51 }
52
53 static void sdp_write_header(char *buff, int size, struct sdp_session_level *s)
54 {
55     av_strlcatf(buff, size, "v=%d\r\n"
56                             "o=- %d %d IN IPV4 %s\r\n"
57                             "t=%d %d\r\n"
58                             "s=%s\r\n"
59                             "a=tool:libavformat\r\n",
60                             s->sdp_version,
61                             s->id, s->version, s->src_addr,
62                             s->start_time, s->end_time,
63                             s->name[0] ? s->name : "No Name");
64     dest_write(buff, size, s->dst_addr, s->ttl);
65 }
66
67 static int get_address(char *dest_addr, int size, int *ttl, const char *url)
68 {
69     int port;
70     const char *p;
71
72     url_split(NULL, 0, NULL, 0, dest_addr, size, &port, NULL, 0, url);
73
74     *ttl = 0;
75     p = strchr(url, '?');
76     if (p) {
77         char buff[64];
78         int is_multicast = find_info_tag(buff, sizeof(buff), "multicast", p);
79
80         if (is_multicast) {
81             if (find_info_tag(buff, sizeof(buff), "ttl", p)) {
82                 *ttl = strtol(buff, NULL, 10);
83             } else {
84                 *ttl = 5;
85             }
86         }
87     }
88
89     return port;
90 }
91
92 static void digit_to_char(char *dst, uint8_t src)
93 {
94     if (src < 10) {
95         *dst = '0' + src;
96     } else {
97         *dst = 'A' + src - 10;
98     }
99 }
100
101 static char *data_to_hex(char *buff, const uint8_t *src, int s)
102 {
103     int i;
104
105     for(i = 0; i < s; i++) {
106         digit_to_char(buff + 2 * i, src[i] >> 4);
107         digit_to_char(buff + 2 * i + 1, src[i] & 0xF);
108     }
109
110     return buff;
111 }
112
113 static char *sdp_media_attributes(char *buff, int size, AVCodecContext *c, int payload_type)
114 {
115     char *config = NULL;
116
117     switch (c->codec_id) {
118         case CODEC_ID_MPEG4:
119             if (c->flags & CODEC_FLAG_GLOBAL_HEADER) {
120                 if (c->extradata_size > MAX_EXTRADATA_SIZE) {
121                     av_log(NULL, AV_LOG_ERROR, "Too many extra data!\n");
122
123                     return NULL;
124                 }
125                 config = av_malloc(10 + c->extradata_size * 2);
126                 if (config == NULL) {
127                     av_log(NULL, AV_LOG_ERROR, "Cannot allocate memory for the config info\n");
128                     return NULL;
129                 }
130                 memcpy(config, "; config=", 9);
131                 data_to_hex(config + 9, c->extradata, c->extradata_size);
132                 config[9 + c->extradata_size * 2] = 0;
133             }
134             av_strlcatf(buff, size, "a=rtpmap:%d MP4V-ES/90000\r\n"
135                                     "a=fmtp:%d profile-level-id=1%s\r\n",
136                                      payload_type,
137                                      payload_type, config ? config : "");
138             break;
139         default:
140             /* Nothing special to do, here... */
141             break;
142     }
143
144     av_free(config);
145
146     return buff;
147 }
148
149 static void sdp_write_media(char *buff, int size, AVCodecContext *c, const char *dest_addr, int port, int ttl)
150 {
151     const char *type;
152     int payload_type;
153
154     payload_type = rtp_get_payload_type(c);
155     if (payload_type < 0) {
156         payload_type = 96;  /* FIXME: how to assign a private pt? rtp.c is broken too */
157     }
158
159     switch (c->codec_type) {
160         case CODEC_TYPE_VIDEO   : type = "video"      ; break;
161         case CODEC_TYPE_AUDIO   : type = "audio"      ; break;
162         case CODEC_TYPE_SUBTITLE: type = "text"       ; break;
163         default                 : type = "application"; break;
164     }
165
166     av_strlcatf(buff, size, "m=%s %d RTP/AVP %d\r\n", type, port, payload_type);
167     dest_write(buff, size, dest_addr, ttl);
168
169     sdp_media_attributes(buff, size, c, payload_type);
170 }
171
172 int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size)
173 {
174     struct sdp_session_level s;
175     int i, j, port, ttl;
176     char dst[32];
177
178     memset(buff, 0, size);
179     memset(&s, 0, sizeof(struct sdp_session_level));
180     s.user = "-";
181     s.src_addr = "127.0.0.1";    /* FIXME: Properly set this */
182     s.name = ac[0]->title;
183
184     port = 0;
185     ttl = 0;
186     if (n_files == 1) {
187         port = get_address(dst, sizeof(dst), &ttl, ac[0]->filename);
188         if (port > 0) {
189             s.dst_addr = dst;
190             s.ttl = ttl;
191         }
192     }
193     sdp_write_header(buff, size, &s);
194
195     dst[0] = 0;
196     for (i = 0; i < n_files; i++) {
197         if (n_files != 1) {
198             port = get_address(dst, sizeof(dst), &ttl, ac[i]->filename);
199         }
200         for (j = 0; j < ac[i]->nb_streams; j++) {
201             sdp_write_media(buff, size,
202                                   ac[i]->streams[j]->codec, dst[0] ? dst : NULL,
203                                   (port > 0) ? port + j * 2 : 0, ttl);
204             if (port <= 0) {
205                 av_strlcatf(buff, size,
206                                    "a=control:streamid=%d\r\n", i + j);
207             }
208         }
209     }
210
211     return 0;
212 }
213 #else
214 int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size)
215 {
216     return AVERROR(ENOSYS);
217 }
218 #endif