cmdutils.c

   1 /*
   2  * Various utilities for command line tools
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <string.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #include <math.h>
  26
  27 /* Include only the enabled headers since some compilers (namely, Sun
  28    Studio) will not omit unused inline functions and create undefined
  29    references to libraries that are not being built. */
  30
  31 #include "config.h"
  32 #include "libavformat/avformat.h"
  33 #include "libavfilter/avfilter.h"
  34 #include "libavdevice/avdevice.h"
  35 #include "libswscale/swscale.h"
  36 #include "libpostproc/postprocess.h"
  37 #include "libavutil/avstring.h"
  38 #include "libavutil/parseutils.h"
  39 #include "libavutil/pixdesc.h"
  40 #include "libavutil/eval.h"
  41 #include "libavutil/dict.h"
  42 #include "libavutil/opt.h"
  43 #include "cmdutils.h"
  44 #include "version.h"
  45 #if CONFIG_NETWORK
  46 #include "libavformat/network.h"
  47 #endif
  48 #if HAVE_SYS_RESOURCE_H
  49 #include <sys/resource.h>
  50 #endif
  51
  52 const char **opt_names;
  53 const char **opt_values;
  54 static int opt_name_count;
  55 AVCodecContext *avcodec_opts[AVMEDIA_TYPE_NB];
  56 AVFormatContext *avformat_opts;
  57 struct SwsContext *sws_opts;
  58 AVDictionary *format_opts, *video_opts, *audio_opts, *sub_opts;
  59
  60 static const int this_year = 2011;
  61
  62 void init_opts(void)
  63 {
  64     int i;
  65     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  66         avcodec_opts[i] = avcodec_alloc_context2(i);
  67     avformat_opts = avformat_alloc_context();
  68 #if CONFIG_SWSCALE
  69     sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC, NULL, NULL, NULL);
  70 #endif
  71 }
  72
  73 void uninit_opts(void)
  74 {
  75     int i;
  76     for (i = 0; i < AVMEDIA_TYPE_NB; i++)
  77         av_freep(&avcodec_opts[i]);
  78     av_freep(&avformat_opts->key);
  79     av_freep(&avformat_opts);
  80 #if CONFIG_SWSCALE
  81     sws_freeContext(sws_opts);
  82     sws_opts = NULL;
  83 #endif
  84     for (i = 0; i < opt_name_count; i++) {
  85         av_freep(&opt_names[i]);
  86         av_freep(&opt_values[i]);
  87     }
  88     av_freep(&opt_names);
  89     av_freep(&opt_values);
  90     opt_name_count = 0;
  91     av_dict_free(&format_opts);
  92     av_dict_free(&video_opts);
  93     av_dict_free(&audio_opts);
  94     av_dict_free(&sub_opts);
  95 }
  96
  97 void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
  98 {
  99     vfprintf(stdout, fmt, vl);
 100 }
 101
 102 double parse_number_or_die(const char *context, const char *numstr, int type, double min, double max)
 103 {
 104     char *tail;
 105     const char *error;
 106     double d = av_strtod(numstr, &tail);
 107     if (*tail)
 108         error= "Expected number for %s but found: %s\n";
 109     else if (d < min || d > max)
 110         error= "The value for %s was %s which is not within %f - %f\n";
 111     else if(type == OPT_INT64 && (int64_t)d != d)
 112         error= "Expected int64 for %s but found %s\n";
 113     else if (type == OPT_INT && (int)d != d)
 114         error= "Expected int for %s but found %s\n";
 115     else
 116         return d;
 117     fprintf(stderr, error, context, numstr, min, max);
 118     exit(1);
 119 }
 120
 121 int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
 122 {
 123     int64_t us;
 124     if (av_parse_time(&us, timestr, is_duration) < 0) {
 125         fprintf(stderr, "Invalid %s specification for %s: %s\n",
 126                 is_duration ? "duration" : "date", context, timestr);
 127         exit(1);
 128     }
 129     return us;
 130 }
 131
 132 void show_help_options(const OptionDef *options, const char *msg, int mask, int value)
 133 {
 134     const OptionDef *po;
 135     int first;
 136
 137     first = 1;
 138     for(po = options; po->name != NULL; po++) {
 139         char buf[64];
 140         if ((po->flags & mask) == value) {
 141             if (first) {
 142                 printf("%s", msg);
 143                 first = 0;
 144             }
 145             av_strlcpy(buf, po->name, sizeof(buf));
 146             if (po->flags & HAS_ARG) {
 147                 av_strlcat(buf, " ", sizeof(buf));
 148                 av_strlcat(buf, po->argname, sizeof(buf));
 149             }
 150             printf("-%-17s  %s\n", buf, po->help);
 151         }
 152     }
 153 }
 154
 155 static const OptionDef* find_option(const OptionDef *po, const char *name){
 156     while (po->name != NULL) {
 157         if (!strcmp(name, po->name))
 158             break;
 159         po++;
 160     }
 161     return po;
 162 }
 163
 164 #if defined(_WIN32) && !defined(__MINGW32CE__)
 165 #include <windows.h>
 166 /* Will be leaked on exit */
 167 static char** win32_argv_utf8 = NULL;
 168 static int win32_argc = 0;
 169
 170 /**
 171  * Prepare command line arguments for executable.
 172  * For Windows - perform wide-char to UTF-8 conversion.
 173  * Input arguments should be main() function arguments.
 174  * @param argc_ptr Arguments number (including executable)
 175  * @param argv_ptr Arguments list.
 176  */
 177 static void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
 178 {
 179     char *argstr_flat;
 180     wchar_t **argv_w;
 181     int i, buffsize = 0, offset = 0;
 182
 183     if (win32_argv_utf8) {
 184         *argc_ptr = win32_argc;
 185         *argv_ptr = win32_argv_utf8;
 186         return;
 187     }
 188
 189     win32_argc = 0;
 190     argv_w = CommandLineToArgvW(GetCommandLineW(), &win32_argc);
 191     if (win32_argc <= 0 || !argv_w)
 192         return;
 193
 194     /* determine the UTF-8 buffer size (including NULL-termination symbols) */
 195     for (i = 0; i < win32_argc; i++)
 196         buffsize += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
 197                                         NULL, 0, NULL, NULL);
 198
 199     win32_argv_utf8 = av_mallocz(sizeof(char*) * (win32_argc + 1) + buffsize);
 200     argstr_flat     = (char*)win32_argv_utf8 + sizeof(char*) * (win32_argc + 1);
 201     if (win32_argv_utf8 == NULL) {
 202         LocalFree(argv_w);
 203         return;
 204     }
 205
 206     for (i = 0; i < win32_argc; i++) {
 207         win32_argv_utf8[i] = &argstr_flat[offset];
 208         offset += WideCharToMultiByte(CP_UTF8, 0, argv_w[i], -1,
 209                                       &argstr_flat[offset],
 210                                       buffsize - offset, NULL, NULL);
 211     }
 212     win32_argv_utf8[i] = NULL;
 213     LocalFree(argv_w);
 214
 215     *argc_ptr = win32_argc;
 216     *argv_ptr = win32_argv_utf8;
 217 }
 218 #else
 219 static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
 220 {
 221     /* nothing to do */
 222 }
 223 #endif /* WIN32 && !__MINGW32CE__ */
 224
 225 void parse_options(int argc, char **argv, const OptionDef *options,
 226                    int (* parse_arg_function)(const char *opt, const char *arg))
 227 {
 228     const char *opt, *arg;
 229     int optindex, handleoptions=1;
 230     const OptionDef *po;
 231
 232     /* perform system-dependent conversions for arguments list */
 233     prepare_app_arguments(&argc, &argv);
 234
 235     /* parse options */
 236     optindex = 1;
 237     while (optindex < argc) {
 238         opt = argv[optindex++];
 239
 240         if (handleoptions && opt[0] == '-' && opt[1] != '\0') {
 241             int bool_val = 1;
 242             if (opt[1] == '-' && opt[2] == '\0') {
 243                 handleoptions = 0;
 244                 continue;
 245             }
 246             opt++;
 247             po= find_option(options, opt);
 248             if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
 249                 /* handle 'no' bool option */
 250                 po = find_option(options, opt + 2);
 251                 if (!(po->name && (po->flags & OPT_BOOL)))
 252                     goto unknown_opt;
 253                 bool_val = 0;
 254             }
 255             if (!po->name)
 256                 po= find_option(options, "default");
 257             if (!po->name) {
 258 unknown_opt:
 259                 fprintf(stderr, "%s: unrecognized option '%s'\n", argv[0], opt);
 260                 exit(1);
 261             }
 262             arg = NULL;
 263             if (po->flags & HAS_ARG) {
 264                 arg = argv[optindex++];
 265                 if (!arg) {
 266                     fprintf(stderr, "%s: missing argument for option '%s'\n", argv[0], opt);
 267                     exit(1);
 268                 }
 269             }
 270             if (po->flags & OPT_STRING) {
 271                 char *str;
 272                 str = av_strdup(arg);
 273                 *po->u.str_arg = str;
 274             } else if (po->flags & OPT_BOOL) {
 275                 *po->u.int_arg = bool_val;
 276             } else if (po->flags & OPT_INT) {
 277                 *po->u.int_arg = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
 278             } else if (po->flags & OPT_INT64) {
 279                 *po->u.int64_arg = parse_number_or_die(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX);
 280             } else if (po->flags & OPT_FLOAT) {
 281                 *po->u.float_arg = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
 282             } else if (po->u.func_arg) {
 283                 if (po->u.func_arg(opt, arg) < 0) {
 284                     fprintf(stderr, "%s: failed to set value '%s' for option '%s'\n", argv[0], arg, opt);
 285                     exit(1);
 286                 }
 287             }
 288             if(po->flags & OPT_EXIT)
 289                 exit(0);
 290         } else {
 291             if (parse_arg_function) {
 292                 if (parse_arg_function(NULL, opt) < 0)
 293                     exit(1);
 294             }
 295         }
 296     }
 297 }
 298
 299 #define FLAGS (o->type == FF_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
 300 #define SET_PREFIXED_OPTS(ch, flag, output) \
 301     if (opt[0] == ch && avcodec_opts[0] && (o = av_opt_find(avcodec_opts[0], opt+1, NULL, flag, 0)))\
 302         av_dict_set(&output, opt+1, arg, FLAGS);
 303 static int opt_default2(const char *opt, const char *arg)
 304 {
 305     const AVOption *o;
 306     if ((o = av_opt_find(avcodec_opts[0], opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
 307         if (o->flags & AV_OPT_FLAG_VIDEO_PARAM)
 308             av_dict_set(&video_opts, opt, arg, FLAGS);
 309         if (o->flags & AV_OPT_FLAG_AUDIO_PARAM)
 310             av_dict_set(&audio_opts, opt, arg, FLAGS);
 311         if (o->flags & AV_OPT_FLAG_SUBTITLE_PARAM)
 312             av_dict_set(&sub_opts, opt, arg, FLAGS);
 313     } else if ((o = av_opt_find(avformat_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN)))
 314         av_dict_set(&format_opts, opt, arg, FLAGS);
 315     else if ((o = av_opt_find(sws_opts, opt, NULL, 0, AV_OPT_SEARCH_CHILDREN))) {
 316         // XXX we only support sws_flags, not arbitrary sws options
 317         int ret = av_set_string3(sws_opts, opt, arg, 1, NULL);
 318         if (ret < 0) {
 319             av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 320             return ret;
 321         }
 322     }
 323
 324     if (!o) {
 325         SET_PREFIXED_OPTS('v', AV_OPT_FLAG_VIDEO_PARAM,    video_opts)
 326         SET_PREFIXED_OPTS('a', AV_OPT_FLAG_AUDIO_PARAM,    audio_opts)
 327         SET_PREFIXED_OPTS('s', AV_OPT_FLAG_SUBTITLE_PARAM, sub_opts)
 328     }
 329
 330     if (o)
 331         return 0;
 332     fprintf(stderr, "Unrecognized option '%s'\n", opt);
 333     return AVERROR_OPTION_NOT_FOUND;
 334 }
 335
 336 int opt_default(const char *opt, const char *arg){
 337     int type;
 338     int ret= 0;
 339     const AVOption *o= NULL;
 340     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 341     AVCodec *p = NULL;
 342     AVOutputFormat *oformat = NULL;
 343     AVInputFormat *iformat = NULL;
 344
 345     while ((p = av_codec_next(p))) {
 346         const AVClass *c = p->priv_class;
 347         if (c && av_find_opt(&c, opt, NULL, 0, 0))
 348             break;
 349     }
 350     if (p)
 351         goto out;
 352     while ((oformat = av_oformat_next(oformat))) {
 353         const AVClass *c = oformat->priv_class;
 354         if (c && av_find_opt(&c, opt, NULL, 0, 0))
 355             break;
 356     }
 357     if (oformat)
 358         goto out;
 359     while ((iformat = av_iformat_next(iformat))) {
 360         const AVClass *c = iformat->priv_class;
 361         if (c && av_find_opt(&c, opt, NULL, 0, 0))
 362             break;
 363     }
 364     if (iformat)
 365         goto out;
 366
 367     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
 368         const AVOption *o2 = av_opt_find(avcodec_opts[0], opt, NULL, opt_types[type], 0);
 369         if(o2)
 370             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 371     }
 372     if(!o && avformat_opts)
 373         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 374     if(!o && sws_opts)
 375         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 376     if(!o){
 377         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
 378             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
 379         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
 380             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
 381         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
 382             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 383         if (ret >= 0)
 384             opt += 1;
 385     }
 386     if (o && ret < 0) {
 387         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 388         exit(1);
 389     }
 390     if (!o) {
 391         fprintf(stderr, "Unrecognized option '%s'\n", opt);
 392         exit(1);
 393     }
 394
 395  out:
 396     if ((ret = opt_default2(opt, arg)) < 0)
 397         return ret;
 398
 399 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avcodec_opts, opt, NULL), (int)av_get_int(avcodec_opts, opt, NULL));
 400
 401     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 402     opt_values[opt_name_count] = av_strdup(arg);
 403     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 404     opt_names[opt_name_count++] = av_strdup(opt);
 405
 406     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 407         av_log_set_level(AV_LOG_DEBUG);
 408     return 0;
 409 }
 410
 411 int opt_loglevel(const char *opt, const char *arg)
 412 {
 413     const struct { const char *name; int level; } log_levels[] = {
 414         { "quiet"  , AV_LOG_QUIET   },
 415         { "panic"  , AV_LOG_PANIC   },
 416         { "fatal"  , AV_LOG_FATAL   },
 417         { "error"  , AV_LOG_ERROR   },
 418         { "warning", AV_LOG_WARNING },
 419         { "info"   , AV_LOG_INFO    },
 420         { "verbose", AV_LOG_VERBOSE },
 421         { "debug"  , AV_LOG_DEBUG   },
 422     };
 423     char *tail;
 424     int level;
 425     int i;
 426
 427     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 428         if (!strcmp(log_levels[i].name, arg)) {
 429             av_log_set_level(log_levels[i].level);
 430             return 0;
 431         }
 432     }
 433
 434     level = strtol(arg, &tail, 10);
 435     if (*tail) {
 436         fprintf(stderr, "Invalid loglevel \"%s\". "
 437                         "Possible levels are numbers or:\n", arg);
 438         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 439             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 440         exit(1);
 441     }
 442     av_log_set_level(level);
 443     return 0;
 444 }
 445
 446 int opt_timelimit(const char *opt, const char *arg)
 447 {
 448 #if HAVE_SETRLIMIT
 449     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 450     struct rlimit rl = { lim, lim + 1 };
 451     if (setrlimit(RLIMIT_CPU, &rl))
 452         perror("setrlimit");
 453 #else
 454     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 455 #endif
 456     return 0;
 457 }
 458
 459 static void *alloc_priv_context(int size, const AVClass *class)
 460 {
 461     void *p = av_mallocz(size);
 462     if (p) {
 463         *(const AVClass **)p = class;
 464         av_opt_set_defaults(p);
 465     }
 466     return p;
 467 }
 468
 469 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 470 {
 471     int i;
 472     void *priv_ctx=NULL;
 473     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 474         AVCodecContext *avctx= ctx;
 475         if(codec && codec->priv_class){
 476             if(!avctx->priv_data && codec->priv_data_size)
 477                 avctx->priv_data= alloc_priv_context(codec->priv_data_size, codec->priv_class);
 478             priv_ctx= avctx->priv_data;
 479         }
 480     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
 481         AVFormatContext *avctx = ctx;
 482         if (avctx->oformat && avctx->oformat->priv_class) {
 483             priv_ctx = avctx->priv_data;
 484         } else if (avctx->iformat && avctx->iformat->priv_class) {
 485             priv_ctx = avctx->priv_data;
 486         }
 487     }
 488
 489     for(i=0; i<opt_name_count; i++){
 490         char buf[256];
 491         const AVOption *opt;
 492         const char *str;
 493         if (priv_ctx) {
 494             if (av_find_opt(priv_ctx, opt_names[i], NULL, flags, flags)) {
 495                 if (av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL) < 0) {
 496                     fprintf(stderr, "Invalid value '%s' for option '%s'\n",
 497                             opt_names[i], opt_values[i]);
 498                     exit(1);
 499                 }
 500             } else
 501                 goto global;
 502         } else {
 503         global:
 504             str = av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 505             /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 506             if (str && ((opt->flags & flags) == flags))
 507                 av_set_string3(ctx, opt_names[i], str, 1, NULL);
 508         }
 509     }
 510 }
 511
 512 void print_error(const char *filename, int err)
 513 {
 514     char errbuf[128];
 515     const char *errbuf_ptr = errbuf;
 516
 517     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 518         errbuf_ptr = strerror(AVUNERROR(err));
 519     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 520 }
 521
 522 static int warned_cfg = 0;
 523
 524 #define INDENT        1
 525 #define SHOW_VERSION  2
 526 #define SHOW_CONFIG   4
 527
 528 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 529     if (CONFIG_##LIBNAME) {                                             \
 530         const char *indent = flags & INDENT? "  " : "";                 \
 531         if (flags & SHOW_VERSION) {                                     \
 532             unsigned int version = libname##_version();                 \
 533             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
 534                     indent, #libname,                                   \
 535                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 536                     LIB##LIBNAME##_VERSION_MINOR,                       \
 537                     LIB##LIBNAME##_VERSION_MICRO,                       \
 538                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 539         }                                                               \
 540         if (flags & SHOW_CONFIG) {                                      \
 541             const char *cfg = libname##_configuration();                \
 542             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 543                 if (!warned_cfg) {                                      \
 544                     fprintf(outstream,                                  \
 545                             "%sWARNING: library configuration mismatch\n", \
 546                             indent);                                    \
 547                     warned_cfg = 1;                                     \
 548                 }                                                       \
 549                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 550                         indent, #libname, cfg);                         \
 551             }                                                           \
 552         }                                                               \
 553     }                                                                   \
 554
 555 static void print_all_libs_info(FILE* outstream, int flags)
 556 {
 557     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 558     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 559     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 560     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 561     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 562     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 563     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 564 }
 565
 566 void show_banner(void)
 567 {
 568     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 569             program_name, program_birth_year, this_year);
 570     fprintf(stderr, "  built on %s %s with %s %s\n",
 571             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 572     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 573     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 574     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 575 }
 576
 577 int opt_version(const char *opt, const char *arg) {
 578     printf("%s " FFMPEG_VERSION "\n", program_name);
 579     print_all_libs_info(stdout, SHOW_VERSION);
 580     return 0;
 581 }
 582
 583 int opt_license(const char *opt, const char *arg)
 584 {
 585     printf(
 586 #if CONFIG_NONFREE
 587     "This version of %s has nonfree parts compiled in.\n"
 588     "Therefore it is not legally redistributable.\n",
 589     program_name
 590 #elif CONFIG_GPLV3
 591     "%s is free software; you can redistribute it and/or modify\n"
 592     "it under the terms of the GNU General Public License as published by\n"
 593     "the Free Software Foundation; either version 3 of the License, or\n"
 594     "(at your option) any later version.\n"
 595     "\n"
 596     "%s is distributed in the hope that it will be useful,\n"
 597     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 598     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 599     "GNU General Public License for more details.\n"
 600     "\n"
 601     "You should have received a copy of the GNU General Public License\n"
 602     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 603     program_name, program_name, program_name
 604 #elif CONFIG_GPL
 605     "%s is free software; you can redistribute it and/or modify\n"
 606     "it under the terms of the GNU General Public License as published by\n"
 607     "the Free Software Foundation; either version 2 of the License, or\n"
 608     "(at your option) any later version.\n"
 609     "\n"
 610     "%s is distributed in the hope that it will be useful,\n"
 611     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 612     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 613     "GNU General Public License for more details.\n"
 614     "\n"
 615     "You should have received a copy of the GNU General Public License\n"
 616     "along with %s; if not, write to the Free Software\n"
 617     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 618     program_name, program_name, program_name
 619 #elif CONFIG_LGPLV3
 620     "%s is free software; you can redistribute it and/or modify\n"
 621     "it under the terms of the GNU Lesser General Public License as published by\n"
 622     "the Free Software Foundation; either version 3 of the License, or\n"
 623     "(at your option) any later version.\n"
 624     "\n"
 625     "%s is distributed in the hope that it will be useful,\n"
 626     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 627     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 628     "GNU Lesser General Public License for more details.\n"
 629     "\n"
 630     "You should have received a copy of the GNU Lesser General Public License\n"
 631     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 632     program_name, program_name, program_name
 633 #else
 634     "%s is free software; you can redistribute it and/or\n"
 635     "modify it under the terms of the GNU Lesser General Public\n"
 636     "License as published by the Free Software Foundation; either\n"
 637     "version 2.1 of the License, or (at your option) any later version.\n"
 638     "\n"
 639     "%s is distributed in the hope that it will be useful,\n"
 640     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 641     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 642     "Lesser General Public License for more details.\n"
 643     "\n"
 644     "You should have received a copy of the GNU Lesser General Public\n"
 645     "License along with %s; if not, write to the Free Software\n"
 646     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 647     program_name, program_name, program_name
 648 #endif
 649     );
 650     return 0;
 651 }
 652
 653 int opt_formats(const char *opt, const char *arg)
 654 {
 655     AVInputFormat *ifmt=NULL;
 656     AVOutputFormat *ofmt=NULL;
 657     const char *last_name;
 658
 659     printf(
 660         "File formats:\n"
 661         " D. = Demuxing supported\n"
 662         " .E = Muxing supported\n"
 663         " --\n");
 664     last_name= "000";
 665     for(;;){
 666         int decode=0;
 667         int encode=0;
 668         const char *name=NULL;
 669         const char *long_name=NULL;
 670
 671         while((ofmt= av_oformat_next(ofmt))) {
 672             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 673                 strcmp(ofmt->name, last_name)>0){
 674                 name= ofmt->name;
 675                 long_name= ofmt->long_name;
 676                 encode=1;
 677             }
 678         }
 679         while((ifmt= av_iformat_next(ifmt))) {
 680             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 681                 strcmp(ifmt->name, last_name)>0){
 682                 name= ifmt->name;
 683                 long_name= ifmt->long_name;
 684                 encode=0;
 685             }
 686             if(name && strcmp(ifmt->name, name)==0)
 687                 decode=1;
 688         }
 689         if(name==NULL)
 690             break;
 691         last_name= name;
 692
 693         printf(
 694             " %s%s %-15s %s\n",
 695             decode ? "D":" ",
 696             encode ? "E":" ",
 697             name,
 698             long_name ? long_name:" ");
 699     }
 700     return 0;
 701 }
 702
 703 int opt_codecs(const char *opt, const char *arg)
 704 {
 705     AVCodec *p=NULL, *p2;
 706     const char *last_name;
 707     printf(
 708         "Codecs:\n"
 709         " D..... = Decoding supported\n"
 710         " .E.... = Encoding supported\n"
 711         " ..V... = Video codec\n"
 712         " ..A... = Audio codec\n"
 713         " ..S... = Subtitle codec\n"
 714         " ...S.. = Supports draw_horiz_band\n"
 715         " ....D. = Supports direct rendering method 1\n"
 716         " .....T = Supports weird frame truncation\n"
 717         " ------\n");
 718     last_name= "000";
 719     for(;;){
 720         int decode=0;
 721         int encode=0;
 722         int cap=0;
 723         const char *type_str;
 724
 725         p2=NULL;
 726         while((p= av_codec_next(p))) {
 727             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 728                 strcmp(p->name, last_name)>0){
 729                 p2= p;
 730                 decode= encode= cap=0;
 731             }
 732             if(p2 && strcmp(p->name, p2->name)==0){
 733                 if(p->decode) decode=1;
 734                 if(p->encode) encode=1;
 735                 cap |= p->capabilities;
 736             }
 737         }
 738         if(p2==NULL)
 739             break;
 740         last_name= p2->name;
 741
 742         switch(p2->type) {
 743         case AVMEDIA_TYPE_VIDEO:
 744             type_str = "V";
 745             break;
 746         case AVMEDIA_TYPE_AUDIO:
 747             type_str = "A";
 748             break;
 749         case AVMEDIA_TYPE_SUBTITLE:
 750             type_str = "S";
 751             break;
 752         default:
 753             type_str = "?";
 754             break;
 755         }
 756         printf(
 757             " %s%s%s%s%s%s %-15s %s",
 758             decode ? "D": (/*p2->decoder ? "d":*/" "),
 759             encode ? "E":" ",
 760             type_str,
 761             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 762             cap & CODEC_CAP_DR1 ? "D":" ",
 763             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 764             p2->name,
 765             p2->long_name ? p2->long_name : "");
 766        /* if(p2->decoder && decode==0)
 767             printf(" use %s for decoding", p2->decoder->name);*/
 768         printf("\n");
 769     }
 770     printf("\n");
 771     printf(
 772 "Note, the names of encoders and decoders do not always match, so there are\n"
 773 "several cases where the above table shows encoder only or decoder only entries\n"
 774 "even though both encoding and decoding are supported. For example, the h263\n"
 775 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 776 "worse.\n");
 777     return 0;
 778 }
 779
 780 int opt_bsfs(const char *opt, const char *arg)
 781 {
 782     AVBitStreamFilter *bsf=NULL;
 783
 784     printf("Bitstream filters:\n");
 785     while((bsf = av_bitstream_filter_next(bsf)))
 786         printf("%s\n", bsf->name);
 787     printf("\n");
 788     return 0;
 789 }
 790
 791 int opt_protocols(const char *opt, const char *arg)
 792 {
 793     URLProtocol *up=NULL;
 794
 795     printf("Supported file protocols:\n"
 796            "I.. = Input  supported\n"
 797            ".O. = Output supported\n"
 798            "..S = Seek   supported\n"
 799            "FLAGS NAME\n"
 800            "----- \n");
 801     while((up = av_protocol_next(up)))
 802         printf("%c%c%c   %s\n",
 803                up->url_read  ? 'I' : '.',
 804                up->url_write ? 'O' : '.',
 805                up->url_seek  ? 'S' : '.',
 806                up->name);
 807     return 0;
 808 }
 809
 810 int opt_filters(const char *opt, const char *arg)
 811 {
 812     AVFilter av_unused(**filter) = NULL;
 813
 814     printf("Filters:\n");
 815 #if CONFIG_AVFILTER
 816     while ((filter = av_filter_next(filter)) && *filter)
 817         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 818 #endif
 819     return 0;
 820 }
 821
 822 int opt_pix_fmts(const char *opt, const char *arg)
 823 {
 824     enum PixelFormat pix_fmt;
 825
 826     printf(
 827         "Pixel formats:\n"
 828         "I.... = Supported Input  format for conversion\n"
 829         ".O... = Supported Output format for conversion\n"
 830         "..H.. = Hardware accelerated format\n"
 831         "...P. = Paletted format\n"
 832         "....B = Bitstream format\n"
 833         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 834         "-----\n");
 835
 836 #if !CONFIG_SWSCALE
 837 #   define sws_isSupportedInput(x)  0
 838 #   define sws_isSupportedOutput(x) 0
 839 #endif
 840
 841     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 842         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 843         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 844                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 845                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 846                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 847                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 848                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 849                pix_desc->name,
 850                pix_desc->nb_components,
 851                av_get_bits_per_pixel(pix_desc));
 852     }
 853     return 0;
 854 }
 855
 856 int read_yesno(void)
 857 {
 858     int c = getchar();
 859     int yesno = (toupper(c) == 'Y');
 860
 861     while (c != '\n' && c != EOF)
 862         c = getchar();
 863
 864     return yesno;
 865 }
 866
 867 int read_file(const char *filename, char **bufptr, size_t *size)
 868 {
 869     FILE *f = fopen(filename, "rb");
 870
 871     if (!f) {
 872         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 873         return AVERROR(errno);
 874     }
 875     fseek(f, 0, SEEK_END);
 876     *size = ftell(f);
 877     fseek(f, 0, SEEK_SET);
 878     *bufptr = av_malloc(*size + 1);
 879     if (!*bufptr) {
 880         fprintf(stderr, "Could not allocate file buffer\n");
 881         fclose(f);
 882         return AVERROR(ENOMEM);
 883     }
 884     fread(*bufptr, 1, *size, f);
 885     (*bufptr)[*size++] = '\0';
 886
 887     fclose(f);
 888     return 0;
 889 }
 890
 891 FILE *get_preset_file(char *filename, size_t filename_size,
 892                       const char *preset_name, int is_path, const char *codec_name)
 893 {
 894     FILE *f = NULL;
 895     int i;
 896     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 897                            getenv("HOME"),
 898                            FFMPEG_DATADIR,
 899                          };
 900
 901     if (is_path) {
 902         av_strlcpy(filename, preset_name, filename_size);
 903         f = fopen(filename, "r");
 904     } else {
 905 #ifdef _WIN32
 906         char datadir[MAX_PATH], *ls;
 907         base[2] = NULL;
 908
 909         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
 910         {
 911             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
 912                 if (*ls == '\\') *ls = '/';
 913
 914             if (ls = strrchr(datadir, '/'))
 915             {
 916                 *ls = 0;
 917                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
 918                 base[2] = datadir;
 919             }
 920         }
 921 #endif
 922         for (i = 0; i < 3 && !f; i++) {
 923             if (!base[i])
 924                 continue;
 925             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 926             f = fopen(filename, "r");
 927             if (!f && codec_name) {
 928                 snprintf(filename, filename_size,
 929                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 930                 f = fopen(filename, "r");
 931             }
 932         }
 933     }
 934
 935     return f;
 936 }