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.
67098 Commits
32 Branches
748MB
Tree: f524d2e47c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f524d2e47c'
${ noResults }
FFmpeg/ffserver_config.c

987 lines
36KB
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. int ffserver_parse_ffconfig(const char *filename, FFServerConfig *config)

  338. {

  339.     FILE *f;

  340.     char line[1024];

  341.     char cmd[64];

  342.     char arg[1024], arg2[1024];

  343.     const char *p;

  344.     int val, errors, warnings, line_num;

  345.     FFServerStream **last_stream, *stream, *redirect;

  346.     FFServerStream **last_feed, *feed, *s;

  347.     AVCodecContext audio_enc, video_enc;

  348.     enum AVCodecID audio_id, video_id;

  349.     int ret = 0;

  350. 

  351.     av_assert0(config);

  352. 

  353.     f = fopen(filename, "r");

  354.     if (!f) {

  355.         ret = AVERROR(errno);

  356.         av_log(NULL, AV_LOG_ERROR, "Could not open the configuration file '%s'\n", filename);

  357.         return ret;

  358.     }

  359. 

  360.     errors = warnings = 0;

  361.     line_num = 0;

  362.     config->first_stream = NULL;

  363.     last_stream = &config->first_stream;

  364.     config->first_feed = NULL;

  365.     last_feed = &config->first_feed;

  366.     stream = NULL;

  367.     feed = NULL;

  368.     redirect = NULL;

  369.     audio_id = AV_CODEC_ID_NONE;

  370.     video_id = AV_CODEC_ID_NONE;

  371. #define ERROR(...)   report_config_error(filename, line_num, AV_LOG_ERROR,   &errors,   __VA_ARGS__)

  372. #define WARNING(...) report_config_error(filename, line_num, AV_LOG_WARNING, &warnings, __VA_ARGS__)

  373. 

  374.     for(;;) {

  375.         if (fgets(line, sizeof(line), f) == NULL)

  376.             break;

  377.         line_num++;

  378.         p = line;

  379.         while (av_isspace(*p))

  380.             p++;

  381.         if (*p == '\0' || *p == '#')

  382.             continue;

  383. 

  384.         ffserver_get_arg(cmd, sizeof(cmd), &p);

  385. 

  386.         if (!av_strcasecmp(cmd, "Port") || !av_strcasecmp(cmd, "HTTPPort")) {

  387.             if (!av_strcasecmp(cmd, "Port"))

  388.                 WARNING("Port option is deprecated, use HTTPPort instead\n");

  389.             ffserver_get_arg(arg, sizeof(arg), &p);

  390.             val = atoi(arg);

  391.             if (val < 1 || val > 65536) {

  392.                 ERROR("Invalid port: %s\n", arg);

  393.             }

  394.             if (val < 1024)

  395.                 WARNING("Trying to use IETF assigned system port: %d\n", val);

  396.             config->http_addr.sin_port = htons(val);

  397.         } else if (!av_strcasecmp(cmd, "HTTPBindAddress") || !av_strcasecmp(cmd, "BindAddress")) {

  398.             if (!av_strcasecmp(cmd, "BindAddress"))

  399.                 WARNING("BindAddress option is deprecated, use HTTPBindAddress instead\n");

  400.             ffserver_get_arg(arg, sizeof(arg), &p);

  401.             if (resolve_host(&config->http_addr.sin_addr, arg) != 0) {

  402.                 ERROR("%s:%d: Invalid host/IP address: %s\n", arg);

  403.             }

  404.         } else if (!av_strcasecmp(cmd, "NoDaemon")) {

  405.             WARNING("NoDaemon option has no effect, you should remove it\n");

  406.         } else if (!av_strcasecmp(cmd, "RTSPPort")) {

  407.             ffserver_get_arg(arg, sizeof(arg), &p);

  408.             val = atoi(arg);

  409.             if (val < 1 || val > 65536) {

  410.                 ERROR("%s:%d: Invalid port: %s\n", arg);

  411.             }

  412.             config->rtsp_addr.sin_port = htons(atoi(arg));

  413.         } else if (!av_strcasecmp(cmd, "RTSPBindAddress")) {

  414.             ffserver_get_arg(arg, sizeof(arg), &p);

  415.             if (resolve_host(&config->rtsp_addr.sin_addr, arg) != 0) {

  416.                 ERROR("Invalid host/IP address: %s\n", arg);

  417.             }

  418.         } else if (!av_strcasecmp(cmd, "MaxHTTPConnections")) {

  419.             ffserver_get_arg(arg, sizeof(arg), &p);

  420.             val = atoi(arg);

  421.             if (val < 1 || val > 65536) {

  422.                 ERROR("Invalid MaxHTTPConnections: %s\n", arg);

  423.             }

  424.             config->nb_max_http_connections = val;

  425.         } else if (!av_strcasecmp(cmd, "MaxClients")) {

  426.             ffserver_get_arg(arg, sizeof(arg), &p);

  427.             val = atoi(arg);

  428.             if (val < 1 || val > config->nb_max_http_connections) {

  429.                 ERROR("Invalid MaxClients: %s\n", arg);

  430.             } else {

  431.                 config->nb_max_connections = val;

  432.             }

  433.         } else if (!av_strcasecmp(cmd, "MaxBandwidth")) {

  434.             int64_t llval;

  435.             ffserver_get_arg(arg, sizeof(arg), &p);

  436.             llval = strtoll(arg, NULL, 10);

  437.             if (llval < 10 || llval > 10000000) {

  438.                 ERROR("Invalid MaxBandwidth: %s\n", arg);

  439.             } else

  440.                 config->max_bandwidth = llval;

  441.         } else if (!av_strcasecmp(cmd, "CustomLog")) {

  442.             if (!config->debug)

  443.                 ffserver_get_arg(config->logfilename, sizeof(config->logfilename), &p);

  444.         } else if (!av_strcasecmp(cmd, "<Feed")) {

  445.             /*********************************************/

  446.             /* Feed related options */

  447.             char *q;

  448.             if (stream || feed) {

  449.                 ERROR("Already in a tag\n");

  450.             } else {

  451.                 feed = av_mallocz(sizeof(FFServerStream));

  452.                 if (!feed) {

  453.                     ret = AVERROR(ENOMEM);

  454.                     goto end;

  455.                 }

  456.                 ffserver_get_arg(feed->filename, sizeof(feed->filename), &p);

  457.                 q = strrchr(feed->filename, '>');

  458.                 if (*q)

  459.                     *q = '\0';

  460. 

  461.                 for (s = config->first_feed; s; s = s->next) {

  462.                     if (!strcmp(feed->filename, s->filename)) {

  463.                         ERROR("Feed '%s' already registered\n", s->filename);

  464.                     }

  465.                 }

  466. 

  467.                 feed->fmt = av_guess_format("ffm", NULL, NULL);

  468.                 /* default feed file */

  469.                 snprintf(feed->feed_filename, sizeof(feed->feed_filename),

  470.                          "/tmp/%s.ffm", feed->filename);

  471.                 feed->feed_max_size = 5 * 1024 * 1024;

  472.                 feed->is_feed = 1;

  473.                 feed->feed = feed; /* self feeding :-) */

  474. 

  475.                 /* add in stream list */

  476.                 *last_stream = feed;

  477.                 last_stream = &feed->next;

  478.                 /* add in feed list */

  479.                 *last_feed = feed;

  480.                 last_feed = &feed->next_feed;

  481.             }

  482.         } else if (!av_strcasecmp(cmd, "Launch")) {

  483.             if (feed) {

  484.                 int i;

  485. 

  486.                 feed->child_argv = av_mallocz(64 * sizeof(char *));

  487.                 if (!feed->child_argv) {

  488.                     ret = AVERROR(ENOMEM);

  489.                     goto end;

  490.                 }

  491.                 for (i = 0; i < 62; i++) {

  492.                     ffserver_get_arg(arg, sizeof(arg), &p);

  493.                     if (!arg[0])

  494.                         break;

  495. 

  496.                     feed->child_argv[i] = av_strdup(arg);

  497.                     if (!feed->child_argv[i]) {

  498.                         ret = AVERROR(ENOMEM);

  499.                         goto end;

  500.                     }

  501.                 }

  502. 

  503.                 feed->child_argv[i] =

  504.                     av_asprintf("http://%s:%d/%s",

  505.                                 (config->http_addr.sin_addr.s_addr == INADDR_ANY) ? "127.0.0.1" :

  506.                                 inet_ntoa(config->http_addr.sin_addr), ntohs(config->http_addr.sin_port),

  507.                                 feed->filename);

  508.                 if (!feed->child_argv[i]) {

  509.                     ret = AVERROR(ENOMEM);

  510.                     goto end;

  511.                 }

  512.             }

  513.         } else if (!av_strcasecmp(cmd, "File") || !av_strcasecmp(cmd, "ReadOnlyFile")) {

  514.             if (feed) {

  515.                 ffserver_get_arg(feed->feed_filename, sizeof(feed->feed_filename), &p);

  516.                 feed->readonly = !av_strcasecmp(cmd, "ReadOnlyFile");

  517.             } else if (stream) {

  518.                 ffserver_get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);

  519.             }

  520.         } else if (!av_strcasecmp(cmd, "Truncate")) {

  521.             if (feed) {

  522.                 ffserver_get_arg(arg, sizeof(arg), &p);

  523.                 /* assume Truncate is true in case no argument is specified */

  524.                 if (!arg[0]) {

  525.                     feed->truncate = 1;

  526.                 } else {

  527.                     WARNING("Truncate N syntax in configuration file is deprecated, "

  528.                             "use Truncate alone with no arguments\n");

  529.                     feed->truncate = strtod(arg, NULL);

  530.                 }

  531.             }

  532.         } else if (!av_strcasecmp(cmd, "FileMaxSize")) {

  533.             if (feed) {

  534.                 char *p1;

  535.                 double fsize;

  536. 

  537.                 ffserver_get_arg(arg, sizeof(arg), &p);

  538.                 p1 = arg;

  539.                 fsize = strtod(p1, &p1);

  540.                 switch(av_toupper(*p1)) {

  541.                 case 'K':

  542.                     fsize *= 1024;

  543.                     break;

  544.                 case 'M':

  545.                     fsize *= 1024 * 1024;

  546.                     break;

  547.                 case 'G':

  548.                     fsize *= 1024 * 1024 * 1024;

  549.                     break;

  550.                 }

  551.                 feed->feed_max_size = (int64_t)fsize;

  552.                 if (feed->feed_max_size < FFM_PACKET_SIZE*4) {

  553.                     ERROR("Feed max file size is too small, must be at least %d\n", FFM_PACKET_SIZE*4);

  554.                 }

  555.             }

  556.         } else if (!av_strcasecmp(cmd, "</Feed>")) {

  557.             if (!feed) {

  558.                 ERROR("No corresponding <Feed> for </Feed>\n");

  559.             }

  560.             feed = NULL;

  561.         } else if (!av_strcasecmp(cmd, "<Stream")) {

  562.             /*********************************************/

  563.             /* Stream related options */

  564.             char *q;

  565.             if (stream || feed) {

  566.                 ERROR("Already in a tag\n");

  567.             } else {

  568.                 FFServerStream *s;

  569.                 stream = av_mallocz(sizeof(FFServerStream));

  570.                 if (!stream) {

  571.                     ret = AVERROR(ENOMEM);

  572.                     goto end;

  573.                 }

  574.                 ffserver_get_arg(stream->filename, sizeof(stream->filename), &p);

  575.                 q = strrchr(stream->filename, '>');

  576.                 if (q)

  577.                     *q = '\0';

  578. 

  579.                 for (s = config->first_stream; s; s = s->next) {

  580.                     if (!strcmp(stream->filename, s->filename)) {

  581.                         ERROR("Stream '%s' already registered\n", s->filename);

  582.                     }

  583.                 }

  584. 

  585.                 stream->fmt = ffserver_guess_format(NULL, stream->filename, NULL);

  586.                 avcodec_get_context_defaults3(&video_enc, NULL);

  587.                 avcodec_get_context_defaults3(&audio_enc, NULL);

  588. 

  589.                 audio_id = AV_CODEC_ID_NONE;

  590.                 video_id = AV_CODEC_ID_NONE;

  591.                 if (stream->fmt) {

  592.                     audio_id = stream->fmt->audio_codec;

  593.                     video_id = stream->fmt->video_codec;

  594.                 }

  595. 

  596.                 *last_stream = stream;

  597.                 last_stream = &stream->next;

  598.             }

  599.         } else if (!av_strcasecmp(cmd, "Feed")) {

  600.             ffserver_get_arg(arg, sizeof(arg), &p);

  601.             if (stream) {

  602.                 FFServerStream *sfeed;

  603. 

  604.                 sfeed = config->first_feed;

  605.                 while (sfeed) {

  606.                     if (!strcmp(sfeed->filename, arg))

  607.                         break;

  608.                     sfeed = sfeed->next_feed;

  609.                 }

  610.                 if (!sfeed)

  611.                     ERROR("Feed with name '%s' for stream '%s' is not defined\n", arg, stream->filename);

  612.                 else

  613.                     stream->feed = sfeed;

  614.             }

  615.         } else if (!av_strcasecmp(cmd, "Format")) {

  616.             ffserver_get_arg(arg, sizeof(arg), &p);

  617.             if (stream) {

  618.                 if (!strcmp(arg, "status")) {

  619.                     stream->stream_type = STREAM_TYPE_STATUS;

  620.                     stream->fmt = NULL;

  621.                 } else {

  622.                     stream->stream_type = STREAM_TYPE_LIVE;

  623.                     /* JPEG cannot be used here, so use single frame MJPEG */

  624.                     if (!strcmp(arg, "jpeg"))

  625.                         strcpy(arg, "mjpeg");

  626.                     stream->fmt = ffserver_guess_format(arg, NULL, NULL);

  627.                     if (!stream->fmt) {

  628.                         ERROR("Unknown Format: %s\n", arg);

  629.                     }

  630.                 }

  631.                 if (stream->fmt) {

  632.                     audio_id = stream->fmt->audio_codec;

  633.                     video_id = stream->fmt->video_codec;

  634.                 }

  635.             }

  636.         } else if (!av_strcasecmp(cmd, "InputFormat")) {

  637.             ffserver_get_arg(arg, sizeof(arg), &p);

  638.             if (stream) {

  639.                 stream->ifmt = av_find_input_format(arg);

  640.                 if (!stream->ifmt) {

  641.                     ERROR("Unknown input format: %s\n", arg);

  642.                 }

  643.             }

  644.         } else if (!av_strcasecmp(cmd, "FaviconURL")) {

  645.             if (stream && stream->stream_type == STREAM_TYPE_STATUS) {

  646.                 ffserver_get_arg(stream->feed_filename, sizeof(stream->feed_filename), &p);

  647.             } else {

  648.                 ERROR("FaviconURL only permitted for status streams\n");

  649.             }

  650.         } else if (!av_strcasecmp(cmd, "Author")    ||

  651.                    !av_strcasecmp(cmd, "Comment")   ||

  652.                    !av_strcasecmp(cmd, "Copyright") ||

  653.                    !av_strcasecmp(cmd, "Title")) {

  654.             ffserver_get_arg(arg, sizeof(arg), &p);

  655. 

  656.             if (stream) {

  657.                 char key[32];

  658.                 int i, ret;

  659. 

  660.                 for (i = 0; i < strlen(cmd); i++)

  661.                     key[i] = av_tolower(cmd[i]);

  662.                 key[i] = 0;

  663.                 WARNING("'%s' option in configuration file is deprecated, "

  664.                         "use 'Metadata %s VALUE' instead\n", cmd, key);

  665.                 if ((ret = av_dict_set(&stream->metadata, key, arg, 0)) < 0) {

  666.                     ERROR("Could not set metadata '%s' to value '%s': %s\n",

  667.                           key, arg, av_err2str(ret));

  668.                 }

  669.             }

  670.         } else if (!av_strcasecmp(cmd, "Metadata")) {

  671.             ffserver_get_arg(arg, sizeof(arg), &p);

  672.             ffserver_get_arg(arg2, sizeof(arg2), &p);

  673.             if (stream) {

  674.                 int ret;

  675.                 if ((ret = av_dict_set(&stream->metadata, arg, arg2, 0)) < 0) {

  676.                     ERROR("Could not set metadata '%s' to value '%s': %s\n",

  677.                           arg, arg2, av_err2str(ret));

  678.                 }

  679.             }

  680.         } else if (!av_strcasecmp(cmd, "Preroll")) {

  681.             ffserver_get_arg(arg, sizeof(arg), &p);

  682.             if (stream)

  683.                 stream->prebuffer = atof(arg) * 1000;

  684.         } else if (!av_strcasecmp(cmd, "StartSendOnKey")) {

  685.             if (stream)

  686.                 stream->send_on_key = 1;

  687.         } else if (!av_strcasecmp(cmd, "AudioCodec")) {

  688.             ffserver_get_arg(arg, sizeof(arg), &p);

  689.             audio_id = opt_codec(arg, AVMEDIA_TYPE_AUDIO);

  690.             if (audio_id == AV_CODEC_ID_NONE) {

  691.                 ERROR("Unknown AudioCodec: %s\n", arg);

  692.             }

  693.         } else if (!av_strcasecmp(cmd, "VideoCodec")) {

  694.             ffserver_get_arg(arg, sizeof(arg), &p);

  695.             video_id = opt_codec(arg, AVMEDIA_TYPE_VIDEO);

  696.             if (video_id == AV_CODEC_ID_NONE) {

  697.                 ERROR("Unknown VideoCodec: %s\n", arg);

  698.             }

  699.         } else if (!av_strcasecmp(cmd, "MaxTime")) {

  700.             ffserver_get_arg(arg, sizeof(arg), &p);

  701.             if (stream)

  702.                 stream->max_time = atof(arg) * 1000;

  703.         } else if (!av_strcasecmp(cmd, "AudioBitRate")) {

  704.             ffserver_get_arg(arg, sizeof(arg), &p);

  705.             if (stream)

  706.                 audio_enc.bit_rate = lrintf(atof(arg) * 1000);

  707.         } else if (!av_strcasecmp(cmd, "AudioChannels")) {

  708.             ffserver_get_arg(arg, sizeof(arg), &p);

  709.             if (stream)

  710.                 audio_enc.channels = atoi(arg);

  711.         } else if (!av_strcasecmp(cmd, "AudioSampleRate")) {

  712.             ffserver_get_arg(arg, sizeof(arg), &p);

  713.             if (stream)

  714.                 audio_enc.sample_rate = atoi(arg);

  715.         } else if (!av_strcasecmp(cmd, "VideoBitRateRange")) {

  716.             if (stream) {

  717.                 int minrate, maxrate;

  718. 

  719.                 ffserver_get_arg(arg, sizeof(arg), &p);

  720. 

  721.                 if (sscanf(arg, "%d-%d", &minrate, &maxrate) == 2) {

  722.                     video_enc.rc_min_rate = minrate * 1000;

  723.                     video_enc.rc_max_rate = maxrate * 1000;

  724.                 } else {

  725.                     ERROR("Incorrect format for VideoBitRateRange -- should be <min>-<max>: %s\n", arg);

  726.                 }

  727.             }

  728.         } else if (!av_strcasecmp(cmd, "Debug")) {

  729.             if (stream) {

  730.                 ffserver_get_arg(arg, sizeof(arg), &p);

  731.                 video_enc.debug = strtol(arg,0,0);

  732.             }

  733.         } else if (!av_strcasecmp(cmd, "Strict")) {

  734.             if (stream) {

  735.                 ffserver_get_arg(arg, sizeof(arg), &p);

  736.                 video_enc.strict_std_compliance = atoi(arg);

  737.             }

  738.         } else if (!av_strcasecmp(cmd, "VideoBufferSize")) {

  739.             if (stream) {

  740.                 ffserver_get_arg(arg, sizeof(arg), &p);

  741.                 video_enc.rc_buffer_size = atoi(arg) * 8*1024;

  742.             }

  743.         } else if (!av_strcasecmp(cmd, "VideoBitRateTolerance")) {

  744.             if (stream) {

  745.                 ffserver_get_arg(arg, sizeof(arg), &p);

  746.                 video_enc.bit_rate_tolerance = atoi(arg) * 1000;

  747.             }

  748.         } else if (!av_strcasecmp(cmd, "VideoBitRate")) {

  749.             ffserver_get_arg(arg, sizeof(arg), &p);

  750.             if (stream) {

  751.                 video_enc.bit_rate = atoi(arg) * 1000;

  752.             }

  753.         } else if (!av_strcasecmp(cmd, "VideoSize")) {

  754.             ffserver_get_arg(arg, sizeof(arg), &p);

  755.             if (stream) {

  756.                 ret = av_parse_video_size(&video_enc.width, &video_enc.height, arg);

  757.                 if (ret < 0) {

  758.                     ERROR("Invalid video size '%s'\n", arg);

  759.                 } else {

  760.                     if ((video_enc.width % 16) != 0 ||

  761.                         (video_enc.height % 16) != 0) {

  762.                         ERROR("Image size must be a multiple of 16\n");

  763.                     }

  764.                 }

  765.             }

  766.         } else if (!av_strcasecmp(cmd, "VideoFrameRate")) {

  767.             ffserver_get_arg(arg, sizeof(arg), &p);

  768.             if (stream) {

  769.                 AVRational frame_rate;

  770.                 if (av_parse_video_rate(&frame_rate, arg) < 0) {

  771.                     ERROR("Incorrect frame rate: %s\n", arg);

  772.                 } else {

  773.                     video_enc.time_base.num = frame_rate.den;

  774.                     video_enc.time_base.den = frame_rate.num;

  775.                 }

  776.             }

  777.         } else if (!av_strcasecmp(cmd, "PixelFormat")) {

  778.             ffserver_get_arg(arg, sizeof(arg), &p);

  779.             if (stream) {

  780.                 video_enc.pix_fmt = av_get_pix_fmt(arg);

  781.                 if (video_enc.pix_fmt == AV_PIX_FMT_NONE) {

  782.                     ERROR("Unknown pixel format: %s\n", arg);

  783.                 }

  784.             }

  785.         } else if (!av_strcasecmp(cmd, "VideoGopSize")) {

  786.             ffserver_get_arg(arg, sizeof(arg), &p);

  787.             if (stream)

  788.                 video_enc.gop_size = atoi(arg);

  789.         } else if (!av_strcasecmp(cmd, "VideoIntraOnly")) {

  790.             if (stream)

  791.                 video_enc.gop_size = 1;

  792.         } else if (!av_strcasecmp(cmd, "VideoHighQuality")) {

  793.             if (stream)

  794.                 video_enc.mb_decision = FF_MB_DECISION_BITS;

  795.         } else if (!av_strcasecmp(cmd, "Video4MotionVector")) {

  796.             if (stream) {

  797.                 video_enc.mb_decision = FF_MB_DECISION_BITS; //FIXME remove

  798.                 video_enc.flags |= CODEC_FLAG_4MV;

  799.             }

  800.         } else if (!av_strcasecmp(cmd, "AVOptionVideo") ||

  801.                    !av_strcasecmp(cmd, "AVOptionAudio")) {

  802.             AVCodecContext *avctx;

  803.             int type;

  804.             ffserver_get_arg(arg, sizeof(arg), &p);

  805.             ffserver_get_arg(arg2, sizeof(arg2), &p);

  806.             if (!av_strcasecmp(cmd, "AVOptionVideo")) {

  807.                 avctx = &video_enc;

  808.                 type = AV_OPT_FLAG_VIDEO_PARAM;

  809.             } else {

  810.                 avctx = &audio_enc;

  811.                 type = AV_OPT_FLAG_AUDIO_PARAM;

  812.             }

  813.             if (ffserver_opt_default(arg, arg2, avctx, type|AV_OPT_FLAG_ENCODING_PARAM)) {

  814.                 ERROR("Error setting %s option to %s %s\n", cmd, arg, arg2);

  815.             }

  816.         } else if (!av_strcasecmp(cmd, "AVPresetVideo") ||

  817.                    !av_strcasecmp(cmd, "AVPresetAudio")) {

  818.             AVCodecContext *avctx;

  819.             int type;

  820.             ffserver_get_arg(arg, sizeof(arg), &p);

  821.             if (!av_strcasecmp(cmd, "AVPresetVideo")) {

  822.                 avctx = &video_enc;

  823.                 video_enc.codec_id = video_id;

  824.                 type = AV_OPT_FLAG_VIDEO_PARAM;

  825.             } else {

  826.                 avctx = &audio_enc;

  827.                 audio_enc.codec_id = audio_id;

  828.                 type = AV_OPT_FLAG_AUDIO_PARAM;

  829.             }

  830.             if (ffserver_opt_preset(arg, avctx, type|AV_OPT_FLAG_ENCODING_PARAM, &audio_id, &video_id)) {

  831.                 ERROR("AVPreset error: %s\n", arg);

  832.             }

  833.         } else if (!av_strcasecmp(cmd, "VideoTag")) {

  834.             ffserver_get_arg(arg, sizeof(arg), &p);

  835.             if ((strlen(arg) == 4) && stream)

  836.                 video_enc.codec_tag = MKTAG(arg[0], arg[1], arg[2], arg[3]);

  837.         } else if (!av_strcasecmp(cmd, "BitExact")) {

  838.             if (stream)

  839.                 video_enc.flags |= CODEC_FLAG_BITEXACT;

  840.         } else if (!av_strcasecmp(cmd, "DctFastint")) {

  841.             if (stream)

  842.                 video_enc.dct_algo  = FF_DCT_FASTINT;

  843.         } else if (!av_strcasecmp(cmd, "IdctSimple")) {

  844.             if (stream)

  845.                 video_enc.idct_algo = FF_IDCT_SIMPLE;

  846.         } else if (!av_strcasecmp(cmd, "Qscale")) {

  847.             ffserver_get_arg(arg, sizeof(arg), &p);

  848.             if (stream) {

  849.                 video_enc.flags |= CODEC_FLAG_QSCALE;

  850.                 video_enc.global_quality = FF_QP2LAMBDA * atoi(arg);

  851.             }

  852.         } else if (!av_strcasecmp(cmd, "VideoQDiff")) {

  853.             ffserver_get_arg(arg, sizeof(arg), &p);

  854.             if (stream) {

  855.                 video_enc.max_qdiff = atoi(arg);

  856.                 if (video_enc.max_qdiff < 1 || video_enc.max_qdiff > 31) {

  857.                     ERROR("VideoQDiff out of range\n");

  858.                 }

  859.             }

  860.         } else if (!av_strcasecmp(cmd, "VideoQMax")) {

  861.             ffserver_get_arg(arg, sizeof(arg), &p);

  862.             if (stream) {

  863.                 video_enc.qmax = atoi(arg);

  864.                 if (video_enc.qmax < 1 || video_enc.qmax > 31) {

  865.                     ERROR("VideoQMax out of range\n");

  866.                 }

  867.             }

  868.         } else if (!av_strcasecmp(cmd, "VideoQMin")) {

  869.             ffserver_get_arg(arg, sizeof(arg), &p);

  870.             if (stream) {

  871.                 video_enc.qmin = atoi(arg);

  872.                 if (video_enc.qmin < 1 || video_enc.qmin > 31) {

  873.                     ERROR("VideoQMin out of range\n");

  874.                 }

  875.             }

  876.         } else if (!av_strcasecmp(cmd, "LumiMask")) {

  877.             ffserver_get_arg(arg, sizeof(arg), &p);

  878.             if (stream)

  879.                 video_enc.lumi_masking = atof(arg);

  880.         } else if (!av_strcasecmp(cmd, "DarkMask")) {

  881.             ffserver_get_arg(arg, sizeof(arg), &p);

  882.             if (stream)

  883.                 video_enc.dark_masking = atof(arg);

  884.         } else if (!av_strcasecmp(cmd, "NoVideo")) {

  885.             video_id = AV_CODEC_ID_NONE;

  886.         } else if (!av_strcasecmp(cmd, "NoAudio")) {

  887.             audio_id = AV_CODEC_ID_NONE;

  888.         } else if (!av_strcasecmp(cmd, "ACL")) {

  889.             ffserver_parse_acl_row(stream, feed, NULL, p, filename, line_num);

  890.         } else if (!av_strcasecmp(cmd, "DynamicACL")) {

  891.             if (stream) {

  892.                 ffserver_get_arg(stream->dynamic_acl, sizeof(stream->dynamic_acl), &p);

  893.             }

  894.         } else if (!av_strcasecmp(cmd, "RTSPOption")) {

  895.             ffserver_get_arg(arg, sizeof(arg), &p);

  896.             if (stream) {

  897.                 av_freep(&stream->rtsp_option);

  898.                 stream->rtsp_option = av_strdup(arg);

  899.             }

  900.         } else if (!av_strcasecmp(cmd, "MulticastAddress")) {

  901.             ffserver_get_arg(arg, sizeof(arg), &p);

  902.             if (stream) {

  903.                 if (resolve_host(&stream->multicast_ip, arg) != 0) {

  904.                     ERROR("Invalid host/IP address: %s\n", arg);

  905.                 }

  906.                 stream->is_multicast = 1;

  907.                 stream->loop = 1; /* default is looping */

  908.             }

  909.         } else if (!av_strcasecmp(cmd, "MulticastPort")) {

  910.             ffserver_get_arg(arg, sizeof(arg), &p);

  911.             if (stream)

  912.                 stream->multicast_port = atoi(arg);

  913.         } else if (!av_strcasecmp(cmd, "MulticastTTL")) {

  914.             ffserver_get_arg(arg, sizeof(arg), &p);

  915.             if (stream)

  916.                 stream->multicast_ttl = atoi(arg);

  917.         } else if (!av_strcasecmp(cmd, "NoLoop")) {

  918.             if (stream)

  919.                 stream->loop = 0;

  920.         } else if (!av_strcasecmp(cmd, "</Stream>")) {

  921.             if (!stream) {

  922.                 ERROR("No corresponding <Stream> for </Stream>\n");

  923.             } else {

  924.                 if (stream->feed && stream->fmt && strcmp(stream->fmt->name, "ffm") != 0) {

  925.                     if (audio_id != AV_CODEC_ID_NONE) {

  926.                         audio_enc.codec_type = AVMEDIA_TYPE_AUDIO;

  927.                         audio_enc.codec_id = audio_id;

  928.                         add_codec(stream, &audio_enc);

  929.                     }

  930.                     if (video_id != AV_CODEC_ID_NONE) {

  931.                         video_enc.codec_type = AVMEDIA_TYPE_VIDEO;

  932.                         video_enc.codec_id = video_id;

  933.                         add_codec(stream, &video_enc);

  934.                     }

  935.                 }

  936.                 stream = NULL;

  937.             }

  938.         } else if (!av_strcasecmp(cmd, "<Redirect")) {

  939.             /*********************************************/

  940.             char *q;

  941.             if (stream || feed || redirect) {

  942.                 ERROR("Already in a tag\n");

  943.             } else {

  944.                 redirect = av_mallocz(sizeof(FFServerStream));

  945.                 if (!redirect) {

  946.                     ret = AVERROR(ENOMEM);

  947.                     goto end;

  948.                 }

  949.                 *last_stream = redirect;

  950.                 last_stream = &redirect->next;

  951. 

  952.                 ffserver_get_arg(redirect->filename, sizeof(redirect->filename), &p);

  953.                 q = strrchr(redirect->filename, '>');

  954.                 if (*q)

  955.                     *q = '\0';

  956.                 redirect->stream_type = STREAM_TYPE_REDIRECT;

  957.             }

  958.         } else if (!av_strcasecmp(cmd, "URL")) {

  959.             if (redirect)

  960.                 ffserver_get_arg(redirect->feed_filename, sizeof(redirect->feed_filename), &p);

  961.         } else if (!av_strcasecmp(cmd, "</Redirect>")) {

  962.             if (!redirect) {

  963.                 ERROR("No corresponding <Redirect> for </Redirect>\n");

  964.             } else {

  965.                 if (!redirect->feed_filename[0]) {

  966.                     ERROR("No URL found for <Redirect>\n");

  967.                 }

  968.                 redirect = NULL;

  969.             }

  970.         } else if (!av_strcasecmp(cmd, "LoadModule")) {

  971.             ERROR("Loadable modules no longer supported\n");

  972.         } else {

  973.             ERROR("Incorrect keyword: '%s'\n", cmd);

  974.         }

  975.     }

  976. #undef ERROR

  977. 

  978. end:

  979.     fclose(f);

  980.     if (ret < 0)

  981.         return ret;

  982.     if (errors)

  983.         return AVERROR(EINVAL);

  984.     else

  985.         return 0;

  986. }