git.sesse.net Git - ffmpeg/blob - ffserver_config.c

   1 /*
   2  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
   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 "libavutil/opt.h"
  22 #include "libavutil/parseutils.h"
  23 #include "libavutil/avstring.h"
  24 #include "libavutil/pixdesc.h"
  25 #include "libavutil/avassert.h"
  26
  27 // FIXME those are internal headers, ffserver _really_ shouldn't use them
  28 #include "libavformat/ffm.h"
  29
  30 #include "cmdutils.h"
  31 #include "ffserver_config.h"
  32
  33 /* FIXME: make ffserver work with IPv6 */
  34 /* resolve host with also IP address parsing */
  35 static int resolve_host(struct in_addr *sin_addr, const char *hostname)
  36 {
  37
  38     if (!ff_inet_aton(hostname, sin_addr)) {
  39 #if HAVE_GETADDRINFO
  40         struct addrinfo *ai, *cur;
  41         struct addrinfo hints = { 0 };
  42         hints.ai_family = AF_INET;
  43         if (getaddrinfo(hostname, NULL, &hints, &ai))
  44             return -1;
  45         /* getaddrinfo returns a linked list of addrinfo structs.
  46          * Even if we set ai_family = AF_INET above, make sure
  47          * that the returned one actually is of the correct type. */
  48         for (cur = ai; cur; cur = cur->ai_next) {
  49             if (cur->ai_family == AF_INET) {
  50                 *sin_addr = ((struct sockaddr_in *)cur->ai_addr)->sin_addr;
  51                 freeaddrinfo(ai);
  52                 return 0;
  53             }
  54         }
  55         freeaddrinfo(ai);
  56         return -1;
  57 #else
  58         struct hostent *hp;
  59         hp = gethostbyname(hostname);
  60         if (!hp)
  61             return -1;
  62         memcpy(sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));
  63 #endif
  64     }
  65     return 0;
  66 }
  67
  68 void ffserver_get_arg(char *buf, int buf_size, const char **pp)
  69 {
  70     const char *p;
  71     char *q;
  72     int quote;
  73
  74     p = *pp;
  75     while (av_isspace(*p)) p++;
  76     q = buf;
  77     quote = 0;
  78     if (*p == '\"' || *p == '\'')
  79         quote = *p++;
  80     for(;;) {
  81         if (quote) {
  82             if (*p == quote)
  83                 break;
  84         } else {
  85             if (av_isspace(*p))
  86                 break;
  87         }
  88         if (*p == '\0')
  89             break;
  90         if ((q - buf) < buf_size - 1)
  91             *q++ = *p;
  92         p++;
  93     }
  94     *q = '\0';
  95     if (quote && *p == quote)
  96         p++;
  97     *pp = p;
  98 }
  99
 100 void ffserver_parse_acl_row(FFServerStream *stream, FFServerStream* feed,
 101                             FFServerIPAddressACL *ext_acl,
 102                             const char *p, const char *filename, int line_num)
 103 {
 104     char arg[1024];
 105     FFServerIPAddressACL acl;
 106     int errors = 0;
 107
 108     ffserver_get_arg(arg, sizeof(arg), &p);
 109     if (av_strcasecmp(arg, "allow") == 0)
 110         acl.action = IP_ALLOW;
 111     else if (av_strcasecmp(arg, "deny") == 0)
 112         acl.action = IP_DENY;
 113     else {
 114         fprintf(stderr, "%s:%d: ACL action '%s' is not ALLOW or DENY\n",
 115                 filename, line_num, arg);
 116         errors++;
 117     }
 118
 119     ffserver_get_arg(arg, sizeof(arg), &p);
 120
 121     if (resolve_host(&acl.first, arg) != 0) {
 122         fprintf(stderr, "%s:%d: ACL refers to invalid host or IP address '%s'\n",
 123                 filename, line_num, arg);
 124         errors++;
 125     } else
 126         acl.last = acl.first;
 127
 128     ffserver_get_arg(arg, sizeof(arg), &p);
 129
 130     if (arg[0]) {
 131         if (resolve_host(&acl.last, arg) != 0) {
 132             fprintf(stderr, "%s:%d: ACL refers to invalid host or IP address '%s'\n",
 133                     filename, line_num, arg);
 134             errors++;
 135         }
 136     }
 137
 138     if (!errors) {
 139         FFServerIPAddressACL *nacl = av_mallocz(sizeof(*nacl));
 140         FFServerIPAddressACL **naclp = 0;
 141
 142         acl.next = 0;
 143         *nacl = acl;
 144
 145         if (stream)
 146             naclp = &stream->acl;
 147         else if (feed)
 148             naclp = &feed->acl;
 149         else if (ext_acl)
 150             naclp = &ext_acl;
 151         else {
 152             fprintf(stderr, "%s:%d: ACL found not in <stream> or <feed>\n",
 153                     filename, line_num);
 154             errors++;
 155         }
 156
 157         if (naclp) {
 158             while (*naclp)
 159                 naclp = &(*naclp)->next;
 160
 161             *naclp = nacl;
 162         } else
 163             av_free(nacl);
 164     }
 165 }
 166
 167 /* add a codec and set the default parameters */
 168 static void add_codec(FFServerStream *stream, AVCodecContext *av)
 169 {
 170     AVStream *st;
 171
 172     if(stream->nb_streams >= FF_ARRAY_ELEMS(stream->streams))
 173         return;
 174
 175     /* compute default parameters */
 176     switch(av->codec_type) {
 177     case AVMEDIA_TYPE_AUDIO:
 178         if (av->bit_rate == 0)
 179             av->bit_rate = 64000;
 180         if (av->sample_rate == 0)
 181             av->sample_rate = 22050;
 182         if (av->channels == 0)
 183             av->channels = 1;
 184         break;
 185     case AVMEDIA_TYPE_VIDEO:
 186         if (av->bit_rate == 0)
 187             av->bit_rate = 64000;
 188         if (av->time_base.num == 0){
 189             av->time_base.den = 5;
 190             av->time_base.num = 1;
 191         }
 192         if (av->width == 0 || av->height == 0) {
 193             av->width = 160;
 194             av->height = 128;
 195         }
 196         /* Bitrate tolerance is less for streaming */
 197         if (av->bit_rate_tolerance == 0)
 198             av->bit_rate_tolerance = FFMAX(av->bit_rate / 4,
 199                       (int64_t)av->bit_rate*av->time_base.num/av->time_base.den);
 200         if (av->qmin == 0)
 201             av->qmin = 3;
 202         if (av->qmax == 0)
 203             av->qmax = 31;
 204         if (av->max_qdiff == 0)
 205             av->max_qdiff = 3;
 206         av->qcompress = 0.5;
 207         av->qblur = 0.5;
 208
 209         if (!av->nsse_weight)
 210             av->nsse_weight = 8;
 211
 212         av->frame_skip_cmp = FF_CMP_DCTMAX;
 213         if (!av->me_method)
 214             av->me_method = ME_EPZS;
 215         av->rc_buffer_aggressivity = 1.0;
 216
 217         if (!av->rc_eq)
 218             av->rc_eq = av_strdup("tex^qComp");
 219         if (!av->i_quant_factor)
 220             av->i_quant_factor = -0.8;
 221         if (!av->b_quant_factor)
 222             av->b_quant_factor = 1.25;
 223         if (!av->b_quant_offset)
 224             av->b_quant_offset = 1.25;
 225         if (!av->rc_max_rate)
 226             av->rc_max_rate = av->bit_rate * 2;
 227
 228         if (av->rc_max_rate && !av->rc_buffer_size) {
 229             av->rc_buffer_size = av->rc_max_rate;
 230         }
 231
 232
 233         break;
 234     default:
 235         abort();
 236     }
 237
 238     st = av_mallocz(sizeof(AVStream));
 239     if (!st)
 240         return;
 241     st->codec = avcodec_alloc_context3(NULL);
 242     stream->streams[stream->nb_streams++] = st;
 243     memcpy(st->codec, av, sizeof(AVCodecContext));
 244 }
 245
 246 static enum AVCodecID opt_codec(const char *name, enum AVMediaType type)
 247 {
 248     AVCodec *codec = avcodec_find_encoder_by_name(name);
 249
 250     if (!codec || codec->type != type)
 251         return AV_CODEC_ID_NONE;
 252     return codec->id;
 253 }
 254
 255 static int ffserver_opt_default(const char *opt, const char *arg,
 256                        AVCodecContext *avctx, int type)
 257 {
 258     int ret = 0;
 259     const AVOption *o = av_opt_find(avctx, opt, NULL, type, 0);
 260     if(o)
 261         ret = av_opt_set(avctx, opt, arg, 0);
 262     return ret;
 263 }
 264
 265 static int ffserver_opt_preset(const char *arg,
 266                        AVCodecContext *avctx, int type,
 267                        enum AVCodecID *audio_id, enum AVCodecID *video_id)
 268 {
 269     FILE *f=NULL;
 270     char filename[1000], tmp[1000], tmp2[1000], line[1000];
 271     int ret = 0;
 272     AVCodec *codec = avcodec_find_encoder(avctx->codec_id);
 273
 274     if (!(f = get_preset_file(filename, sizeof(filename), arg, 0,
 275                               codec ? codec->name : NULL))) {
 276         fprintf(stderr, "File for preset '%s' not found\n", arg);
 277         return 1;
 278     }
 279
 280     while(!feof(f)){
 281         int e= fscanf(f, "%999[^\n]\n", line) - 1;
 282         if(line[0] == '#' && !e)
 283             continue;
 284         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
 285         if(e){
 286             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
 287             ret = 1;
 288             break;
 289         }
 290         if(!strcmp(tmp, "acodec")){
 291             *audio_id = opt_codec(tmp2, AVMEDIA_TYPE_AUDIO);
 292         }else if(!strcmp(tmp, "vcodec")){
 293             *video_id = opt_codec(tmp2, AVMEDIA_TYPE_VIDEO);
 294         }else if(!strcmp(tmp, "scodec")){
 295             /* opt_subtitle_codec(tmp2); */
 296         }else if(ffserver_opt_default(tmp, tmp2, avctx, type) < 0){
 297             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
 298             ret = 1;
 299             break;
 300         }
 301     }
 302
 303     fclose(f);
 304
 305     return ret;
 306 }
 307
 308 static AVOutputFormat *ffserver_guess_format(const char *short_name, const char *filename, const char *mime_type)
 309 {
 310     AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
 311
 312     if (fmt) {
 313         AVOutputFormat *stream_fmt;
 314         char stream_format_name[64];
 315
 316         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
 317         stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
 318
 319         if (stream_fmt)
 320             fmt = stream_fmt;
 321     }
 322
 323     return fmt;
 324 }
 325
 326 static void report_config_error(const char *filename, int line_num, int log_level, int *errors, const char *fmt, ...)
 327 {
 328     va_list vl;
 329     va_start(vl, fmt);
 330     av_log(NULL, log_level, "%s:%d: ", filename, line_num);
 331     av_vlog(NULL, log_level, fmt, vl);
 332     va_end(vl);
 333
 334     (*errors)++;
 335 }
 336
 337 #define ERROR(...)   report_config_error(config->filename, line_num, AV_LOG_ERROR,   &config->errors,   __VA_ARGS__)
 338 #define WARNING(...) report_config_error(config->filename, line_num, AV_LOG_WARNING, &config->warnings, __VA_ARGS__)
 339
 340 static int ffserver_parse_config_global(FFServerConfig *config, const char *cmd,
 341                                         const char **p, int line_num)
 342 {
 343     int val;
 344     char arg[1024];
 345     if (!av_strcasecmp(cmd, "Port") || !av_strcasecmp(cmd, "HTTPPort")) {
 346         if (!av_strcasecmp(cmd, "Port"))
 347             WARNING("Port option is deprecated, use HTTPPort instead\n");
 348         ffserver_get_arg(arg, sizeof(arg), p);
 349         val = atoi(arg);
 350         if (val < 1 || val > 65536)
 351             ERROR("Invalid port: %s\n", arg);
 352         if (val < 1024)
 353             WARNING("Trying to use IETF assigned system port: %d\n", val);
 354         config->http_addr.sin_port = htons(val);
 355     } else if (!av_strcasecmp(cmd, "HTTPBindAddress") || !av_strcasecmp(cmd, "BindAddress")) {
 356         if (!av_strcasecmp(cmd, "BindAddress"))
 357             WARNING("BindAddress option is deprecated, use HTTPBindAddress instead\n");
 358         ffserver_get_arg(arg, sizeof(arg), p);
 359         if (resolve_host(&config->http_addr.sin_addr, arg) != 0)
 360             ERROR("%s:%d: Invalid host/IP address: %s\n", arg);
 361     } else if (!av_strcasecmp(cmd, "NoDaemon")) {
 362         WARNING("NoDaemon option has no effect, you should remove it\n");
 363     } else if (!av_strcasecmp(cmd, "RTSPPort")) {
 364         ffserver_get_arg(arg, sizeof(arg), p);
 365         val = atoi(arg);
 366         if (val < 1 || val > 65536)
 367             ERROR("%s:%d: Invalid port: %s\n", arg);
 368         config->rtsp_addr.sin_port = htons(atoi(arg));
 369     } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {
 370         ffserver_get_arg(arg, sizeof(arg), p);
 371         if (resolve_host(&config->rtsp_addr.sin_addr, arg) != 0)
 372             ERROR("Invalid host/IP address: %s\n", arg);
 373     } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {
 374         ffserver_get_arg(arg, sizeof(arg), p);
 375         val = atoi(arg);
 376         if (val < 1 || val > 65536)
 377             ERROR("Invalid MaxHTTPConnections: %s\n", arg);
 378         config->nb_max_http_connections = val;
 379     } else if (!av_strcasecmp(cmd, "MaxClients")) {
 380         ffserver_get_arg(arg, sizeof(arg), p);
 381         val = atoi(arg);
 382         if (val < 1 || val > config->nb_max_http_connections)
 383             ERROR("Invalid MaxClients: %s\n", arg);
 384         else
 385             config->nb_max_connections = val;
 386     } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {
 387         int64_t llval;
 388         ffserver_get_arg(arg, sizeof(arg), p);
 389         llval = strtoll(arg, NULL, 10);
 390         if (llval < 10 || llval > 10000000)
 391             ERROR("Invalid MaxBandwidth: %s\n", arg);
 392         else
 393             config->max_bandwidth = llval;
 394     } else if (!av_strcasecmp(cmd, "CustomLog")) {
 395         if (!config->debug)
 396             ffserver_get_arg(config->logfilename, sizeof(config->logfilename), p);
 397     } else if (!av_strcasecmp(cmd, "LoadModule")) {
 398         ERROR("Loadable modules no longer supported\n");
 399     } else
 400         ERROR("Incorrect keyword: '%s'\n", cmd);
 401     return 0;
 402 }
 403
 404 static int ffserver_parse_config_feed(FFServerConfig *config, const char *cmd, const char **p,
 405                                       int line_num, FFServerStream **pfeed)
 406 {
 407     FFServerStream *feed;
 408     char arg[1024];
 409     av_assert0(pfeed);
 410     feed = *pfeed;
 411     if (!av_strcasecmp(cmd, "<Feed")) {
 412         char *q;
 413         FFServerStream *s;
 414         feed = av_mallocz(sizeof(FFServerStream));
 415         if (!feed)
 416             return AVERROR(ENOMEM);
 417         ffserver_get_arg(feed->filename, sizeof(feed->filename), p);
 418         q = strrchr(feed->filename, '>');
 419         if (*q)
 420             *q = '\0';
 421
 422         for (s = config->first_feed; s; s = s->next) {
 423             if (!strcmp(feed->filename, s->filename))
 424                 ERROR("Feed '%s' already registered\n", s->filename);
 425         }
 426
 427         feed->fmt = av_guess_format("ffm", NULL, NULL);
 428         /* default feed file */
 429         snprintf(feed->feed_filename, sizeof(feed->feed_filename),
 430                  "/tmp/%s.ffm", feed->filename);
 431         feed->feed_max_size = 5 * 1024 * 1024;
 432         feed->is_feed = 1;
 433         feed->feed = feed; /* self feeding :-) */
 434         *pfeed = feed;
 435         return 0;
 436     }
 437     av_assert0(feed);
 438     if (!av_strcasecmp(cmd, "Launch")) {
 439         int i;
 440
 441         feed->child_argv = av_mallocz(64 * sizeof(char *));
 442         if (!feed->child_argv)
 443             return AVERROR(ENOMEM);
 444         for (i = 0; i < 62; i++) {
 445             ffserver_get_arg(arg, sizeof(arg), p);
 446             if (!arg[0])
 447                 break;
 448
 449             feed->child_argv[i] = av_strdup(arg);
 450             if (!feed->child_argv[i])
 451                 return AVERROR(ENOMEM);
 452         }
 453
 454         feed->child_argv[i] =
 455             av_asprintf("http://%s:%d/%s",
 456                         (config->http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :
 457                         inet_ntoa(config->http_addr.sin_addr), ntohs(config->http_addr.sin_port),
 458                         feed->filename);
 459         if (!feed->child_argv[i])
 460             return AVERROR(ENOMEM);
 461     } else if (!av_strcasecmp(cmd, "ACL")) {
 462         ffserver_parse_acl_row(NULL, feed, NULL, *p, config->filename, line_num);
 463     } else if (!av_strcasecmp(cmd, "File") || !av_strcasecmp(cmd, "ReadOnlyFile")) {
 464         ffserver_get_arg(feed->feed_filename, sizeof(feed->feed_filename), p);
 465         feed->readonly = !av_strcasecmp(cmd, "ReadOnlyFile");
 466     } else if (!av_strcasecmp(cmd, "Truncate")) {
 467         ffserver_get_arg(arg, sizeof(arg), p);
 468         /* assume Truncate is true in case no argument is specified */
 469         if (!arg[0]) {
 470             feed->truncate = 1;
 471         } else {
 472             WARNING("Truncate N syntax in configuration file is deprecated, "
 473                     "use Truncate alone with no arguments\n");
 474             feed->truncate = strtod(arg, NULL);
 475         }
 476     } else if (!av_strcasecmp(cmd, "FileMaxSize")) {
 477         char *p1;
 478         double fsize;
 479
 480         ffserver_get_arg(arg, sizeof(arg), p);
 481         p1 = arg;
 482         fsize = strtod(p1, &p1);
 483         switch(av_toupper(*p1)) {
 484         case 'K':
 485             fsize *= 1024;
 486             break;
 487         case 'M':
 488             fsize *= 1024 * 1024;
 489             break;
 490         case 'G':
 491             fsize *= 1024 * 1024 * 1024;
 492             break;
 493         }
 494         feed->feed_max_size = (int64_t)fsize;
 495         if (feed->feed_max_size < FFM_PACKET_SIZE*4)
 496             ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);
 497     } else if (!av_strcasecmp(cmd, "</Feed>")) {
 498         *pfeed = NULL;
 499     } else {
 500         ERROR("Invalid entry '%s' inside <Feed></Feed>\n", cmd);
 501     }
 502     return 0;
 503 }
 504
 505 static int ffserver_parse_config_stream(FFServerConfig *config, const char *cmd, const char **p,
 506                                         int line_num, FFServerStream **pstream)
 507 {
 508     char arg[1024], arg2[1024];
 509     FFServerStream *stream;
 510
 511     av_assert0(pstream);
 512     stream = *pstream;
 513
 514     if (!av_strcasecmp(cmd, "<Stream")) {
 515         char *q;
 516         FFServerStream *s;
 517         stream = av_mallocz(sizeof(FFServerStream));
 518         if (!stream)
 519             return AVERROR(ENOMEM);
 520         ffserver_get_arg(stream->filename, sizeof(stream->filename), p);
 521         q = strrchr(stream->filename, '>');
 522         if (q)
 523             *q = '\0';
 524
 525         for (s = config->first_stream; s; s = s->next) {
 526             if (!strcmp(stream->filename, s->filename))
 527                 ERROR("Stream '%s' already registered\n", s->filename);
 528         }
 529
 530         stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);
 531         avcodec_get_context_defaults3(&config->video_enc, NULL);
 532         avcodec_get_context_defaults3(&config->audio_enc, NULL);
 533
 534         config->audio_id = AV_CODEC_ID_NONE;
 535         config->video_id = AV_CODEC_ID_NONE;
 536         if (stream->fmt) {
 537             config->audio_id = stream->fmt->audio_codec;
 538             config->video_id = stream->fmt->video_codec;
 539         }
 540         *pstream = stream;
 541         return 0;
 542     }
 543     av_assert0(stream);
 544     if (!av_strcasecmp(cmd, "Feed")) {
 545         FFServerStream *sfeed;
 546         ffserver_get_arg(arg, sizeof(arg), p);
 547         sfeed = config->first_feed;
 548         while (sfeed) {
 549             if (!strcmp(sfeed->filename, arg))
 550                 break;
 551             sfeed = sfeed->next_feed;
 552         }
 553         if (!sfeed)
 554             ERROR("Feed with name '%s' for stream '%s' is not defined\n", arg, stream->filename);
 555         else
 556             stream->feed = sfeed;
 557     } else if (!av_strcasecmp(cmd, "Format")) {
 558         ffserver_get_arg(arg, sizeof(arg), p);
 559         if (!strcmp(arg, "status")) {
 560             stream->stream_type = STREAM_TYPE_STATUS;
 561             stream->fmt = NULL;
 562         } else {
 563             stream->stream_type = STREAM_TYPE_LIVE;
 564             /* JPEG cannot be used here, so use single frame MJPEG */
 565             if (!strcmp(arg, "jpeg"))
 566                 strcpy(arg, "mjpeg");
 567             stream->fmt = ffserver_guess_format(arg, NULL, NULL);
 568             if (!stream->fmt)
 569                 ERROR("Unknown Format: %s\n", arg);
 570         }
 571         if (stream->fmt) {
 572             config->audio_id = stream->fmt->audio_codec;
 573             config->video_id = stream->fmt->video_codec;
 574         }
 575     } else if (!av_strcasecmp(cmd, "InputFormat")) {
 576         ffserver_get_arg(arg, sizeof(arg), p);
 577         stream->ifmt = av_find_input_format(arg);
 578         if (!stream->ifmt)
 579             ERROR("Unknown input format: %s\n", arg);
 580     } else if (!av_strcasecmp(cmd, "FaviconURL")) {
 581         if (stream->stream_type == STREAM_TYPE_STATUS)
 582             ffserver_get_arg(stream->feed_filename, sizeof(stream->feed_filename), p);
 583         else
 584             ERROR("FaviconURL only permitted for status streams\n");
 585     } else if (!av_strcasecmp(cmd, "Author")    ||
 586                !av_strcasecmp(cmd, "Comment")   ||
 587                !av_strcasecmp(cmd, "Copyright") ||
 588                !av_strcasecmp(cmd, "Title")) {
 589         char key[32];
 590         int i, ret;
 591         ffserver_get_arg(arg, sizeof(arg), p);
 592         for (i = 0; i < strlen(cmd); i++)
 593             key[i] = av_tolower(cmd[i]);
 594         key[i] = 0;
 595         WARNING("'%s' option in configuration file is deprecated, "
 596                 "use 'Metadata %s VALUE' instead\n", cmd, key);
 597         if ((ret = av_dict_set(&stream->metadata, key, arg, 0)) < 0)
 598             ERROR("Could not set metadata '%s' to value '%s': %s\n", key, arg, av_err2str(ret));
 599     } else if (!av_strcasecmp(cmd, "Metadata")) {
 600         int ret;
 601         ffserver_get_arg(arg, sizeof(arg), p);
 602         ffserver_get_arg(arg2, sizeof(arg2), p);
 603         if ((ret = av_dict_set(&stream->metadata, arg, arg2, 0)) < 0) {
 604             ERROR("Could not set metadata '%s' to value '%s': %s\n",
 605                   arg, arg2, av_err2str(ret));
 606         }
 607     } else if (!av_strcasecmp(cmd, "Preroll")) {
 608         ffserver_get_arg(arg, sizeof(arg), p);
 609         stream->prebuffer = atof(arg) * 1000;
 610     } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {
 611         stream->send_on_key = 1;
 612     } else if (!av_strcasecmp(cmd, "AudioCodec")) {
 613         ffserver_get_arg(arg, sizeof(arg), p);
 614         config->audio_id = opt_codec(arg, AVMEDIA_TYPE_AUDIO);
 615         if (config->audio_id == AV_CODEC_ID_NONE)
 616             ERROR("Unknown AudioCodec: %s\n", arg);
 617     } else if (!av_strcasecmp(cmd, "VideoCodec")) {
 618         ffserver_get_arg(arg, sizeof(arg), p);
 619         config->video_id = opt_codec(arg, AVMEDIA_TYPE_VIDEO);
 620         if (config->video_id == AV_CODEC_ID_NONE)
 621             ERROR("Unknown VideoCodec: %s\n", arg);
 622     } else if (!av_strcasecmp(cmd, "MaxTime")) {
 623         ffserver_get_arg(arg, sizeof(arg), p);
 624         stream->max_time = atof(arg) * 1000;
 625     } else if (!av_strcasecmp(cmd, "AudioBitRate")) {
 626         ffserver_get_arg(arg, sizeof(arg), p);
 627         config->audio_enc.bit_rate = lrintf(atof(arg) * 1000);
 628     } else if (!av_strcasecmp(cmd, "AudioChannels")) {
 629         ffserver_get_arg(arg, sizeof(arg), p);
 630         config->audio_enc.channels = atoi(arg);
 631     } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {
 632         ffserver_get_arg(arg, sizeof(arg), p);
 633         config->audio_enc.sample_rate = atoi(arg);
 634     } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {
 635         int minrate, maxrate;
 636         ffserver_get_arg(arg, sizeof(arg), p);
 637         if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {
 638             config->video_enc.rc_min_rate = minrate * 1000;
 639             config->video_enc.rc_max_rate = maxrate * 1000;
 640         } else
 641             ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);
 642     } else if (!av_strcasecmp(cmd, "Debug")) {
 643         ffserver_get_arg(arg, sizeof(arg), p);
 644         config->video_enc.debug = strtol(arg,0,0);
 645     } else if (!av_strcasecmp(cmd, "Strict")) {
 646         ffserver_get_arg(arg, sizeof(arg), p);
 647         config->video_enc.strict_std_compliance = atoi(arg);
 648     } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {
 649         ffserver_get_arg(arg, sizeof(arg), p);
 650         config->video_enc.rc_buffer_size = atoi(arg) * 8*1024;
 651     } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {
 652         ffserver_get_arg(arg, sizeof(arg), p);
 653         config->video_enc.bit_rate_tolerance = atoi(arg) * 1000;
 654     } else if (!av_strcasecmp(cmd, "VideoBitRate")) {
 655         ffserver_get_arg(arg, sizeof(arg), p);
 656         config->video_enc.bit_rate = atoi(arg) * 1000;
 657     } else if (!av_strcasecmp(cmd, "VideoSize")) {
 658         int ret;
 659         ffserver_get_arg(arg, sizeof(arg), p);
 660         ret = av_parse_video_size(&config->video_enc.width, &config->video_enc.height, arg);
 661         if (ret < 0)
 662             ERROR("Invalid video size '%s'\n", arg);
 663         else if ((config->video_enc.width % 16) != 0 || (config->video_enc.height % 16) != 0)
 664             ERROR("Image size must be a multiple of 16\n");
 665     } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {
 666         AVRational frame_rate;
 667         ffserver_get_arg(arg, sizeof(arg), p);
 668         if (av_parse_video_rate(&frame_rate, arg) < 0) {
 669             ERROR("Incorrect frame rate: %s\n", arg);
 670         } else {
 671             config->video_enc.time_base.num = frame_rate.den;
 672             config->video_enc.time_base.den = frame_rate.num;
 673         }
 674     } else if (!av_strcasecmp(cmd, "PixelFormat")) {
 675         ffserver_get_arg(arg, sizeof(arg), p);
 676         config->video_enc.pix_fmt = av_get_pix_fmt(arg);
 677         if (config->video_enc.pix_fmt == AV_PIX_FMT_NONE)
 678             ERROR("Unknown pixel format: %s\n", arg);
 679     } else if (!av_strcasecmp(cmd, "VideoGopSize")) {
 680         ffserver_get_arg(arg, sizeof(arg), p);
 681         config->video_enc.gop_size = atoi(arg);
 682     } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {
 683         config->video_enc.gop_size = 1;
 684     } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {
 685         config->video_enc.mb_decision = FF_MB_DECISION_BITS;
 686     } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {
 687         config->video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove
 688         config->video_enc.flags |= CODEC_FLAG_4MV;
 689     } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||
 690                !av_strcasecmp(cmd, "AVOptionAudio")) {
 691         AVCodecContext *avctx;
 692         int type;
 693         ffserver_get_arg(arg, sizeof(arg), p);
 694         ffserver_get_arg(arg2, sizeof(arg2), p);
 695         if (!av_strcasecmp(cmd, "AVOptionVideo")) {
 696             avctx = &config->video_enc;
 697             type = AV_OPT_FLAG_VIDEO_PARAM;
 698         } else {
 699             avctx = &config->audio_enc;
 700             type = AV_OPT_FLAG_AUDIO_PARAM;
 701         }
 702         if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {
 703             ERROR("Error setting %s option to %s %s\n", cmd, arg, arg2);
 704         }
 705     } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||
 706                !av_strcasecmp(cmd, "AVPresetAudio")) {
 707         AVCodecContext *avctx;
 708         int type;
 709         ffserver_get_arg(arg, sizeof(arg), p);
 710         if (!av_strcasecmp(cmd, "AVPresetVideo")) {
 711             avctx = &config->video_enc;
 712             config->video_enc.codec_id = config->video_id;
 713             type = AV_OPT_FLAG_VIDEO_PARAM;
 714         } else {
 715             avctx = &config->audio_enc;
 716             config->audio_enc.codec_id = config->audio_id;
 717             type = AV_OPT_FLAG_AUDIO_PARAM;
 718         }
 719         if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &config->audio_id, &config->video_id)) {
 720             ERROR("AVPreset error: %s\n", arg);
 721         }
 722     } else if (!av_strcasecmp(cmd, "VideoTag")) {
 723         ffserver_get_arg(arg, sizeof(arg), p);
 724         if (strlen(arg) == 4)
 725             config->video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);
 726     } else if (!av_strcasecmp(cmd, "BitExact")) {
 727         config->video_enc.flags |= CODEC_FLAG_BITEXACT;
 728     } else if (!av_strcasecmp(cmd, "DctFastint")) {
 729         config->video_enc.dct_algo  = FF_DCT_FASTINT;
 730     } else if (!av_strcasecmp(cmd, "IdctSimple")) {
 731         config->video_enc.idct_algo = FF_IDCT_SIMPLE;
 732     } else if (!av_strcasecmp(cmd, "Qscale")) {
 733         ffserver_get_arg(arg, sizeof(arg), p);
 734         config->video_enc.flags |= CODEC_FLAG_QSCALE;
 735         config->video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);
 736     } else if (!av_strcasecmp(cmd, "VideoQDiff")) {
 737         ffserver_get_arg(arg, sizeof(arg), p);
 738         config->video_enc.max_qdiff = atoi(arg);
 739         if (config->video_enc.max_qdiff < 1 || config->video_enc.max_qdiff > 31)
 740             ERROR("VideoQDiff out of range\n");
 741     } else if (!av_strcasecmp(cmd, "VideoQMax")) {
 742         ffserver_get_arg(arg, sizeof(arg), p);
 743         config->video_enc.qmax = atoi(arg);
 744         if (config->video_enc.qmax < 1 || config->video_enc.qmax > 31)
 745             ERROR("VideoQMax out of range\n");
 746     } else if (!av_strcasecmp(cmd, "VideoQMin")) {
 747         ffserver_get_arg(arg, sizeof(arg), p);
 748         config->video_enc.qmin = atoi(arg);
 749         if (config->video_enc.qmin < 1 || config->video_enc.qmin > 31)
 750             ERROR("VideoQMin out of range\n");
 751     } else if (!av_strcasecmp(cmd, "LumiMask")) {
 752         ffserver_get_arg(arg, sizeof(arg), p);
 753         config->video_enc.lumi_masking = atof(arg);
 754     } else if (!av_strcasecmp(cmd, "DarkMask")) {
 755         ffserver_get_arg(arg, sizeof(arg), p);
 756         config->video_enc.dark_masking = atof(arg);
 757     } else if (!av_strcasecmp(cmd, "NoVideo")) {
 758         config->video_id = AV_CODEC_ID_NONE;
 759     } else if (!av_strcasecmp(cmd, "NoAudio")) {
 760         config->audio_id = AV_CODEC_ID_NONE;
 761     } else if (!av_strcasecmp(cmd, "ACL")) {
 762         ffserver_parse_acl_row(stream, NULL, NULL, *p, config->filename, line_num);
 763     } else if (!av_strcasecmp(cmd, "DynamicACL")) {
 764         ffserver_get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), p);
 765     } else if (!av_strcasecmp(cmd, "RTSPOption")) {
 766         ffserver_get_arg(arg, sizeof(arg), p);
 767         av_freep(&stream->rtsp_option);
 768         stream->rtsp_option = av_strdup(arg);
 769     } else if (!av_strcasecmp(cmd, "MulticastAddress")) {
 770         ffserver_get_arg(arg, sizeof(arg), p);
 771         if (resolve_host(&stream->multicast_ip, arg) != 0)
 772             ERROR("Invalid host/IP address: %s\n", arg);
 773         stream->is_multicast = 1;
 774         stream->loop = 1; /* default is looping */
 775     } else if (!av_strcasecmp(cmd, "MulticastPort")) {
 776         ffserver_get_arg(arg, sizeof(arg), p);
 777         stream->multicast_port = atoi(arg);
 778     } else if (!av_strcasecmp(cmd, "MulticastTTL")) {
 779         ffserver_get_arg(arg, sizeof(arg), p);
 780         stream->multicast_ttl = atoi(arg);
 781     } else if (!av_strcasecmp(cmd, "NoLoop")) {
 782         stream->loop = 0;
 783     } else if (!av_strcasecmp(cmd, "</Stream>")) {
 784         if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {
 785             if (config->audio_id != AV_CODEC_ID_NONE) {
 786                 config->audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;
 787                 config->audio_enc.codec_id = config->audio_id;
 788                 add_codec(stream, &config->audio_enc);
 789             }
 790             if (config->video_id != AV_CODEC_ID_NONE) {
 791                 config->video_enc.codec_type = AVMEDIA_TYPE_VIDEO;
 792                 config->video_enc.codec_id = config->video_id;
 793                 add_codec(stream, &config->video_enc);
 794             }
 795         }
 796         *pstream = NULL;
 797     } else if (!av_strcasecmp(cmd, "File") || !av_strcasecmp(cmd, "ReadOnlyFile")) {
 798         ffserver_get_arg(stream->feed_filename, sizeof(stream->feed_filename), p);
 799     } else {
 800         ERROR("Invalid entry '%s' inside <Stream></Stream>\n", cmd);
 801     }
 802     return 0;
 803 }
 804
 805 static int ffserver_parse_config_redirect(FFServerConfig *config, const char *cmd, const char **p,
 806                                           int line_num, FFServerStream **predirect)
 807 {
 808     FFServerStream *redirect;
 809     av_assert0(predirect);
 810     redirect = *predirect;
 811
 812     if (!av_strcasecmp(cmd, "<Redirect")) {
 813         char *q;
 814         redirect = av_mallocz(sizeof(FFServerStream));
 815         if (!redirect)
 816             return AVERROR(ENOMEM);
 817
 818         ffserver_get_arg(redirect->filename, sizeof(redirect->filename), p);
 819         q = strrchr(redirect->filename, '>');
 820         if (*q)
 821             *q = '\0';
 822         redirect->stream_type = STREAM_TYPE_REDIRECT;
 823         *predirect = redirect;
 824         return 0;
 825     }
 826     av_assert0(redirect);
 827     if (!av_strcasecmp(cmd, "URL")) {
 828         ffserver_get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), p);
 829     } else if (!av_strcasecmp(cmd, "</Redirect>")) {
 830         if (!redirect->feed_filename[0])
 831             ERROR("No URL found for <Redirect>\n");
 832         *predirect = NULL;
 833     } else {
 834         ERROR("Invalid entry '%s' inside <Redirect></Redirect>\n", cmd);
 835     }
 836     return 0;
 837 }
 838
 839 int ffserver_parse_ffconfig(const char *filename, FFServerConfig *config)
 840 {
 841     FILE *f;
 842     char line[1024];
 843     char cmd[64];
 844     const char *p;
 845     int line_num = 0;
 846     FFServerStream **last_stream, *stream = NULL, *redirect = NULL;
 847     FFServerStream **last_feed, *feed = NULL;
 848     int ret = 0;
 849
 850     av_assert0(config);
 851
 852     f = fopen(filename, "r");
 853     if (!f) {
 854         ret = AVERROR(errno);
 855         av_log(NULL, AV_LOG_ERROR, "Could not open the configuration file '%s'\n", filename);
 856         return ret;
 857     }
 858
 859     config->first_stream = NULL;
 860     last_stream = &config->first_stream;
 861     config->first_feed = NULL;
 862     last_feed = &config->first_feed;
 863     config->errors = config->warnings = 0;
 864
 865     for(;;) {
 866         if (fgets(line, sizeof(line), f) == NULL)
 867             break;
 868         line_num++;
 869         p = line;
 870         while (av_isspace(*p))
 871             p++;
 872         if (*p == '\0' || *p == '#')
 873             continue;
 874
 875         ffserver_get_arg(cmd, sizeof(cmd), &p);
 876
 877         if (feed || !av_strcasecmp(cmd, "<Feed")) {
 878             int opening = !av_strcasecmp(cmd, "<Feed");
 879             if (opening && (stream || feed || redirect)) {
 880                 ERROR("Already in a tag\n");
 881             } else {
 882                 if ((ret = ffserver_parse_config_feed(config, cmd, &p, line_num, &feed)) < 0)
 883                     break;
 884                 if (opening) {
 885                     /* add in stream list */
 886                     *last_stream = feed;
 887                     last_stream = &feed->next;
 888                     /* add in feed list */
 889                     *last_feed = feed;
 890                     last_feed = &feed->next_feed;
 891                 }
 892             }
 893         } else if (stream || !av_strcasecmp(cmd, "<Stream")) {
 894             int opening = !av_strcasecmp(cmd, "<Stream");
 895             if (opening && (stream || feed || redirect)) {
 896                 ERROR("Already in a tag\n");
 897             } else {
 898                 if ((ret = ffserver_parse_config_stream(config, cmd, &p, line_num, &stream)) < 0)
 899                     break;
 900                 if (opening) {
 901                     /* add in stream list */
 902                     *last_stream = stream;
 903                     last_stream = &stream->next;
 904                 }
 905             }
 906         } else if (redirect || !av_strcasecmp(cmd, "<Redirect")) {
 907             int opening = !av_strcasecmp(cmd, "<Redirect");
 908             if (opening && (stream || feed || redirect))
 909                 ERROR("Already in a tag\n");
 910             else {
 911                 if ((ret = ffserver_parse_config_redirect(config, cmd, &p, line_num, &redirect)) < 0)
 912                     break;
 913                 if (opening) {
 914                     /* add in stream list */
 915                     *last_stream = redirect;
 916                     last_stream = &redirect->next;
 917                 }
 918             }
 919         } else {
 920             ffserver_parse_config_global(config, cmd, &p, line_num);
 921         }
 922     }
 923
 924     fclose(f);
 925     if (ret < 0)
 926         return ret;
 927     if (config->errors)
 928         return AVERROR(EINVAL);
 929     else
 930         return 0;
 931 }
 932
 933 #undef ERROR
 934 #undef WARNING