FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavformat/icecast.c
Date:	2026-09-02 11:02:20

	Total	Coverage
Lines:	83	0.0%
Functions:	4	0.0%
Branches:	58	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Icecast protocol for FFmpeg
    
       * Copyright (c) 2014 Marvin Scholz
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      #include "libavutil/bprint.h"
    
      #include "libavutil/mem.h"
    
      #include "libavutil/opt.h"
    
      #include "avformat.h"
    
      #include "network.h"
    
      typedef struct IcecastContext {
    
          const AVClass *class;
    
          URLContext *hd;
    
          int send_started;
    
          char *user;
    
          // Options
    
          char *content_type;
    
          char *description;
    
          char *genre;
    
          int legacy_icecast;
    
          char *name;
    
          char *pass;
    
          int public;
    
          char *url;
    
          char *user_agent;
    
          int tls;
    
      } IcecastContext;
    
      #define DEFAULT_ICE_USER "source"
    
      #define NOT_EMPTY(s) (s && s[0])
    
      #define OFFSET(x) offsetof(IcecastContext, x)
    
      #define E AV_OPT_FLAG_ENCODING_PARAM
    
      static const AVOption options[] = {
    
          { "ice_genre", "set stream genre", OFFSET(genre), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "ice_name", "set stream description", OFFSET(name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "ice_description", "set stream description", OFFSET(description), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "ice_url", "set stream website", OFFSET(url), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "ice_public", "set if stream is public", OFFSET(public), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
    
          { "user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "password", "set password", OFFSET(pass), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "content_type", "set content-type, MUST be set if not audio/mpeg", OFFSET(content_type), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
    
          { "legacy_icecast", "use legacy SOURCE method, for Icecast < v2.4", OFFSET(legacy_icecast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
    
          { "tls", "use a TLS connection", OFFSET(tls), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
    
          { NULL }
    
      };
    
      ✗
      static void cat_header(AVBPrint *bp, const char key[], const char value[])
    
      {
    
      ✗
          if (NOT_EMPTY(value)) {
    
      ✗
              if (strpbrk(value, "\r\n")) {
    
      ✗
                  av_log(NULL, AV_LOG_ERROR,
    
                         "Refusing to send '%s' header: value contains CR/LF\n", key);
    
      ✗
                  return;
    
              }
    
      ✗
              av_bprintf(bp, "%s: %s\r\n", key, value);
    
          }
    
      }
    
      ✗
      static int icecast_close(URLContext *h)
    
      {
    
      ✗
          IcecastContext *s = h->priv_data;
    
      ✗
          ffurl_closep(&s->hd);
    
      ✗
          return 0;
    
      }
    
      ✗
      static int icecast_open(URLContext *h, const char *uri, int flags)
    
      {
    
      ✗
          IcecastContext *s = h->priv_data;
    
          // Dict to set options that we pass to the HTTP protocol
    
      ✗
          AVDictionary *opt_dict = NULL;
    
          // URI part variables
    
          char h_url[1024], host[1024], auth[1024], path[1024];
    
      ✗
          char *headers, *user = NULL;
    
          int port, ret;
    
          AVBPrint bp;
    
      ✗
          if (flags & AVIO_FLAG_READ)
    
      ✗
              return AVERROR(ENOSYS);
    
      ✗
          av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
    
          // Build header strings
    
      ✗
          cat_header(&bp, "Ice-Name", s->name);
    
      ✗
          cat_header(&bp, "Ice-Description", s->description);
    
      ✗
          cat_header(&bp, "Ice-URL", s->url);
    
      ✗
          cat_header(&bp, "Ice-Genre", s->genre);
    
      ✗
          cat_header(&bp, "Ice-Public", s->public ? "1" : "0");
    
      ✗
          if (!av_bprint_is_complete(&bp)) {
    
      ✗
              av_bprint_finalize(&bp, NULL);
    
      ✗
              return AVERROR(ENOMEM);
    
          }
    
      ✗
          if ((ret = av_bprint_finalize(&bp, &headers)) < 0)
    
      ✗
              return ret;
    
          // Set options
    
      ✗
          av_dict_set(&opt_dict, "method", s->legacy_icecast ? "SOURCE" : "PUT", 0);
    
      ✗
          av_dict_set(&opt_dict, "auth_type", "basic", 0);
    
      ✗
          av_dict_set(&opt_dict, "headers", headers, AV_DICT_DONT_STRDUP_VAL);
    
      ✗
          av_dict_set(&opt_dict, "chunked_post", "0", 0);
    
      ✗
          av_dict_set(&opt_dict, "send_expect_100", s->legacy_icecast ? "-1" : "1", 0);
    
      ✗
          if (NOT_EMPTY(s->content_type))
    
      ✗
              av_dict_set(&opt_dict, "content_type", s->content_type, 0);
    
          else
    
      ✗
              av_dict_set(&opt_dict, "content_type", "audio/mpeg", 0);
    
      ✗
          if (NOT_EMPTY(s->user_agent))
    
      ✗
              av_dict_set(&opt_dict, "user_agent", s->user_agent, 0);
    
          // Parse URI
    
      ✗
          av_url_split(NULL, 0, auth, sizeof(auth), host, sizeof(host),
    
                       &port, path, sizeof(path), uri);
    
          // Check for auth data in URI
    
      ✗
          if (auth[0]) {
    
      ✗
              char *sep = strchr(auth, ':');
    
      ✗
              if (sep) {
    
      ✗
                  *sep = 0;
    
      ✗
                  sep++;
    
      ✗
                  if (s->pass) {
    
      ✗
                      av_free(s->pass);
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Overwriting -password <pass> with URI password!\n");
    
                  }
    
      ✗
                  if (!(s->pass = av_strdup(sep))) {
    
      ✗
                      ret = AVERROR(ENOMEM);
    
      ✗
                      goto cleanup;
    
                  }
    
              }
    
      ✗
              if (!(user = av_strdup(auth))) {
    
      ✗
                  ret = AVERROR(ENOMEM);
    
      ✗
                  goto cleanup;
    
              }
    
          }
    
          // Build new authstring
    
      ✗
          snprintf(auth, sizeof(auth),
    
                   "%s:%s",
    
      ✗
                   user ? user : DEFAULT_ICE_USER,
    
      ✗
                   s->pass ? s->pass : "");
    
          // Check for mountpoint (path)
    
      ✗
          if (!path[0] || strcmp(path, "/") == 0) {
    
      ✗
              av_log(h, AV_LOG_ERROR, "No mountpoint (path) specified!\n");
    
      ✗
              ret = AVERROR(EIO);
    
      ✗
              goto cleanup;
    
          }
    
          // Build new URI for passing to http protocol
    
      ✗
          ff_url_join(h_url, sizeof(h_url),
    
      ✗
                      s->tls ? "https" : "http",
    
                      auth, host, port, "%s", path);
    
          // Finally open http proto handler
    
      ✗
          ret = ffurl_open_whitelist(&s->hd, h_url, AVIO_FLAG_READ_WRITE, NULL,
    
                                     &opt_dict, h->protocol_whitelist, h->protocol_blacklist, h);
    
      ✗
      cleanup:
    
      ✗
          av_freep(&user);
    
      ✗
          av_dict_free(&opt_dict);
    
      ✗
          return ret;
    
      }
    
      ✗
      static int icecast_write(URLContext *h, const uint8_t *buf, int size)
    
      {
    
      ✗
          IcecastContext *s = h->priv_data;
    
      ✗
          if (!s->send_started) {
    
      ✗
              s->send_started = 1;
    
      ✗
              if (!s->content_type && size >= 8) {
    
                  static const uint8_t oggs[4] = { 0x4F, 0x67, 0x67, 0x53 };
    
                  static const uint8_t webm[4] = { 0x1A, 0x45, 0xDF, 0xA3 };
    
                  static const uint8_t opus[8] = { 0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64 };
    
      ✗
                  if (memcmp(buf, oggs, sizeof(oggs)) == 0) {
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Streaming Ogg but appropriate content type NOT set!\n");
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Set it with -content_type application/ogg\n");
    
      ✗
                  } else if (memcmp(buf, opus, sizeof(opus)) == 0) {
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Streaming Opus but appropriate content type NOT set!\n");
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Set it with -content_type audio/ogg\n");
    
      ✗
                  } else if (memcmp(buf, webm, sizeof(webm)) == 0) {
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Streaming WebM but appropriate content type NOT set!\n");
    
      ✗
                      av_log(h, AV_LOG_WARNING, "Set it with -content_type video/webm\n");
    
                  } else {
    
      ✗
                      av_log(h, AV_LOG_WARNING, "It seems you are streaming an unsupported format.\n");
    
      ✗
                      av_log(h, AV_LOG_WARNING, "It might work, but is not officially supported in Icecast!\n");
    
                  }
    
              }
    
          }
    
      ✗
          return ffurl_write(s->hd, buf, size);
    
      }
    
      static const AVClass icecast_context_class = {
    
          .class_name     = "icecast",
    
          .item_name      = av_default_item_name,
    
          .option         = options,
    
          .version        = LIBAVUTIL_VERSION_INT,
    
      };
    
      const URLProtocol ff_icecast_protocol = {
    
          .name            = "icecast",
    
          .url_open        = icecast_open,
    
          .url_write       = icecast_write,
    
          .url_close       = icecast_close,
    
          .priv_data_size  = sizeof(IcecastContext),
    
          .priv_data_class = &icecast_context_class,
    
          .flags           = URL_PROTOCOL_FLAG_NETWORK,
    
      };

Line	Exec	Source
1		/*
2		* Icecast protocol for FFmpeg
3		* Copyright (c) 2014 Marvin Scholz
4		*
5		* This file is part of FFmpeg.
6		*
7		* FFmpeg is free software; you can redistribute it and/or
8		* modify it under the terms of the GNU Lesser General Public
9		* License as published by the Free Software Foundation; either
10		* version 2.1 of the License, or (at your option) any later version.
11		*
12		* FFmpeg is distributed in the hope that it will be useful,
13		* but WITHOUT ANY WARRANTY; without even the implied warranty of
14		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15		* Lesser General Public License for more details.
16		*
17		* You should have received a copy of the GNU Lesser General Public
18		* License along with FFmpeg; if not, write to the Free Software
19		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20		*/
21
22
23		#include "libavutil/bprint.h"
24		#include "libavutil/mem.h"
25		#include "libavutil/opt.h"
26
27		#include "avformat.h"
28		#include "network.h"
29
30
31		typedef struct IcecastContext {
32		const AVClass *class;
33		URLContext *hd;
34		int send_started;
35		char *user;
36		// Options
37		char *content_type;
38		char *description;
39		char *genre;
40		int legacy_icecast;
41		char *name;
42		char *pass;
43		int public;
44		char *url;
45		char *user_agent;
46		int tls;
47		} IcecastContext;
48
49		#define DEFAULT_ICE_USER "source"
50
51		#define NOT_EMPTY(s) (s && s[0])
52
53		#define OFFSET(x) offsetof(IcecastContext, x)
54		#define E AV_OPT_FLAG_ENCODING_PARAM
55
56		static const AVOption options[] = {
57		{ "ice_genre", "set stream genre", OFFSET(genre), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
58		{ "ice_name", "set stream description", OFFSET(name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
59		{ "ice_description", "set stream description", OFFSET(description), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
60		{ "ice_url", "set stream website", OFFSET(url), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
61		{ "ice_public", "set if stream is public", OFFSET(public), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
62		{ "user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
63		{ "password", "set password", OFFSET(pass), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
64		{ "content_type", "set content-type, MUST be set if not audio/mpeg", OFFSET(content_type), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
65		{ "legacy_icecast", "use legacy SOURCE method, for Icecast < v2.4", OFFSET(legacy_icecast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
66		{ "tls", "use a TLS connection", OFFSET(tls), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
67		{ NULL }
68		};
69
70
71	✗	static void cat_header(AVBPrint *bp, const char key[], const char value[])
72		{
73	✗	if (NOT_EMPTY(value)) {
74	✗	if (strpbrk(value, "\r\n")) {
75	✗	av_log(NULL, AV_LOG_ERROR,
76		"Refusing to send '%s' header: value contains CR/LF\n", key);
77	✗	return;
78		}
79	✗	av_bprintf(bp, "%s: %s\r\n", key, value);
80		}
81		}
82
83	✗	static int icecast_close(URLContext *h)
84		{
85	✗	IcecastContext *s = h->priv_data;
86	✗	ffurl_closep(&s->hd);
87	✗	return 0;
88		}
89
90	✗	static int icecast_open(URLContext h, const char uri, int flags)
91		{
92	✗	IcecastContext *s = h->priv_data;
93
94		// Dict to set options that we pass to the HTTP protocol
95	✗	AVDictionary *opt_dict = NULL;
96
97		// URI part variables
98		char h_url[1024], host[1024], auth[1024], path[1024];
99	✗	char headers, user = NULL;
100		int port, ret;
101		AVBPrint bp;
102
103	✗	if (flags & AVIO_FLAG_READ)
104	✗	return AVERROR(ENOSYS);
105
106	✗	av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
107
108		// Build header strings
109	✗	cat_header(&bp, "Ice-Name", s->name);
110	✗	cat_header(&bp, "Ice-Description", s->description);
111	✗	cat_header(&bp, "Ice-URL", s->url);
112	✗	cat_header(&bp, "Ice-Genre", s->genre);
113	✗	cat_header(&bp, "Ice-Public", s->public ? "1" : "0");
114	✗	if (!av_bprint_is_complete(&bp)) {
115	✗	av_bprint_finalize(&bp, NULL);
116	✗	return AVERROR(ENOMEM);
117		}
118	✗	if ((ret = av_bprint_finalize(&bp, &headers)) < 0)
119	✗	return ret;
120
121		// Set options
122	✗	av_dict_set(&opt_dict, "method", s->legacy_icecast ? "SOURCE" : "PUT", 0);
123	✗	av_dict_set(&opt_dict, "auth_type", "basic", 0);
124	✗	av_dict_set(&opt_dict, "headers", headers, AV_DICT_DONT_STRDUP_VAL);
125	✗	av_dict_set(&opt_dict, "chunked_post", "0", 0);
126	✗	av_dict_set(&opt_dict, "send_expect_100", s->legacy_icecast ? "-1" : "1", 0);
127	✗	if (NOT_EMPTY(s->content_type))
128	✗	av_dict_set(&opt_dict, "content_type", s->content_type, 0);
129		else
130	✗	av_dict_set(&opt_dict, "content_type", "audio/mpeg", 0);
131	✗	if (NOT_EMPTY(s->user_agent))
132	✗	av_dict_set(&opt_dict, "user_agent", s->user_agent, 0);
133
134		// Parse URI
135	✗	av_url_split(NULL, 0, auth, sizeof(auth), host, sizeof(host),
136		&port, path, sizeof(path), uri);
137
138		// Check for auth data in URI
139	✗	if (auth[0]) {
140	✗	char *sep = strchr(auth, ':');
141	✗	if (sep) {
142	✗	*sep = 0;
143	✗	sep++;
144	✗	if (s->pass) {
145	✗	av_free(s->pass);
146	✗	av_log(h, AV_LOG_WARNING, "Overwriting -password <pass> with URI password!\n");
147		}
148	✗	if (!(s->pass = av_strdup(sep))) {
149	✗	ret = AVERROR(ENOMEM);
150	✗	goto cleanup;
151		}
152		}
153	✗	if (!(user = av_strdup(auth))) {
154	✗	ret = AVERROR(ENOMEM);
155	✗	goto cleanup;
156		}
157		}
158
159		// Build new authstring
160	✗	snprintf(auth, sizeof(auth),
161		"%s:%s",
162	✗	user ? user : DEFAULT_ICE_USER,
163	✗	s->pass ? s->pass : "");
164
165		// Check for mountpoint (path)
166	✗	if (!path[0] \|\| strcmp(path, "/") == 0) {
167	✗	av_log(h, AV_LOG_ERROR, "No mountpoint (path) specified!\n");
168	✗	ret = AVERROR(EIO);
169	✗	goto cleanup;
170		}
171
172		// Build new URI for passing to http protocol
173	✗	ff_url_join(h_url, sizeof(h_url),
174	✗	s->tls ? "https" : "http",
175		auth, host, port, "%s", path);
176		// Finally open http proto handler
177	✗	ret = ffurl_open_whitelist(&s->hd, h_url, AVIO_FLAG_READ_WRITE, NULL,
178		&opt_dict, h->protocol_whitelist, h->protocol_blacklist, h);
179
180	✗	cleanup:
181	✗	av_freep(&user);
182	✗	av_dict_free(&opt_dict);
183
184	✗	return ret;
185		}
186
187	✗	static int icecast_write(URLContext h, const uint8_t buf, int size)
188		{
189	✗	IcecastContext *s = h->priv_data;
190	✗	if (!s->send_started) {
191	✗	s->send_started = 1;
192	✗	if (!s->content_type && size >= 8) {
193		static const uint8_t oggs[4] = { 0x4F, 0x67, 0x67, 0x53 };
194		static const uint8_t webm[4] = { 0x1A, 0x45, 0xDF, 0xA3 };
195		static const uint8_t opus[8] = { 0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64 };
196	✗	if (memcmp(buf, oggs, sizeof(oggs)) == 0) {
197	✗	av_log(h, AV_LOG_WARNING, "Streaming Ogg but appropriate content type NOT set!\n");
198	✗	av_log(h, AV_LOG_WARNING, "Set it with -content_type application/ogg\n");
199	✗	} else if (memcmp(buf, opus, sizeof(opus)) == 0) {
200	✗	av_log(h, AV_LOG_WARNING, "Streaming Opus but appropriate content type NOT set!\n");
201	✗	av_log(h, AV_LOG_WARNING, "Set it with -content_type audio/ogg\n");
202	✗	} else if (memcmp(buf, webm, sizeof(webm)) == 0) {
203	✗	av_log(h, AV_LOG_WARNING, "Streaming WebM but appropriate content type NOT set!\n");
204	✗	av_log(h, AV_LOG_WARNING, "Set it with -content_type video/webm\n");
205		} else {
206	✗	av_log(h, AV_LOG_WARNING, "It seems you are streaming an unsupported format.\n");
207	✗	av_log(h, AV_LOG_WARNING, "It might work, but is not officially supported in Icecast!\n");
208		}
209		}
210		}
211	✗	return ffurl_write(s->hd, buf, size);
212		}
213
214		static const AVClass icecast_context_class = {
215		.class_name = "icecast",
216		.item_name = av_default_item_name,
217		.option = options,
218		.version = LIBAVUTIL_VERSION_INT,
219		};
220
221		const URLProtocol ff_icecast_protocol = {
222		.name = "icecast",
223		.url_open = icecast_open,
224		.url_write = icecast_write,
225		.url_close = icecast_close,
226		.priv_data_size = sizeof(IcecastContext),
227		.priv_data_class = &icecast_context_class,
228		.flags = URL_PROTOCOL_FLAG_NETWORK,
229		};
230

Function (Line)	Call count	Block coverage
cat_header (line 71)	not called	0.0%
icecast_close (line 83)	not called	0.0%
icecast_open (line 90)	not called	0.0%
icecast_write (line 187)	not called	0.0%