falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
67154 Commits
32 Branches
802MB
Tree: af89c14418
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'af89c14418'
${ noResults }
FFmpeg/ffserver_config.c

935 lines
34KB
Raw Blame History 

  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