git.sesse.net Git - ffmpeg/blob - 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 ? arg : "[null]", 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 void show_version(void) {
 578     printf("%s " FFMPEG_VERSION "\n", program_name);
 579     print_all_libs_info(stdout, SHOW_VERSION);
 580 }
 581
 582 void show_license(void)
 583 {
 584     printf(
 585 #if CONFIG_NONFREE
 586     "This version of %s has nonfree parts compiled in.\n"
 587     "Therefore it is not legally redistributable.\n",
 588     program_name
 589 #elif CONFIG_GPLV3
 590     "%s is free software; you can redistribute it and/or modify\n"
 591     "it under the terms of the GNU General Public License as published by\n"
 592     "the Free Software Foundation; either version 3 of the License, or\n"
 593     "(at your option) any later version.\n"
 594     "\n"
 595     "%s is distributed in the hope that it will be useful,\n"
 596     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 597     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 598     "GNU General Public License for more details.\n"
 599     "\n"
 600     "You should have received a copy of the GNU General Public License\n"
 601     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 602     program_name, program_name, program_name
 603 #elif CONFIG_GPL
 604     "%s is free software; you can redistribute it and/or modify\n"
 605     "it under the terms of the GNU General Public License as published by\n"
 606     "the Free Software Foundation; either version 2 of the License, or\n"
 607     "(at your option) any later version.\n"
 608     "\n"
 609     "%s is distributed in the hope that it will be useful,\n"
 610     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 611     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 612     "GNU General Public License for more details.\n"
 613     "\n"
 614     "You should have received a copy of the GNU General Public License\n"
 615     "along with %s; if not, write to the Free Software\n"
 616     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 617     program_name, program_name, program_name
 618 #elif CONFIG_LGPLV3
 619     "%s is free software; you can redistribute it and/or modify\n"
 620     "it under the terms of the GNU Lesser General Public License as published by\n"
 621     "the Free Software Foundation; either version 3 of the License, or\n"
 622     "(at your option) any later version.\n"
 623     "\n"
 624     "%s is distributed in the hope that it will be useful,\n"
 625     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 626     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 627     "GNU Lesser General Public License for more details.\n"
 628     "\n"
 629     "You should have received a copy of the GNU Lesser General Public License\n"
 630     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 631     program_name, program_name, program_name
 632 #else
 633     "%s is free software; you can redistribute it and/or\n"
 634     "modify it under the terms of the GNU Lesser General Public\n"
 635     "License as published by the Free Software Foundation; either\n"
 636     "version 2.1 of the License, or (at your option) any later version.\n"
 637     "\n"
 638     "%s is distributed in the hope that it will be useful,\n"
 639     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 640     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 641     "Lesser General Public License for more details.\n"
 642     "\n"
 643     "You should have received a copy of the GNU Lesser General Public\n"
 644     "License along with %s; if not, write to the Free Software\n"
 645     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 646     program_name, program_name, program_name
 647 #endif
 648     );
 649 }
 650
 651 void show_formats(void)
 652 {
 653     AVInputFormat *ifmt=NULL;
 654     AVOutputFormat *ofmt=NULL;
 655     const char *last_name;
 656
 657     printf(
 658         "File formats:\n"
 659         " D. = Demuxing supported\n"
 660         " .E = Muxing supported\n"
 661         " --\n");
 662     last_name= "000";
 663     for(;;){
 664         int decode=0;
 665         int encode=0;
 666         const char *name=NULL;
 667         const char *long_name=NULL;
 668
 669         while((ofmt= av_oformat_next(ofmt))) {
 670             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 671                 strcmp(ofmt->name, last_name)>0){
 672                 name= ofmt->name;
 673                 long_name= ofmt->long_name;
 674                 encode=1;
 675             }
 676         }
 677         while((ifmt= av_iformat_next(ifmt))) {
 678             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 679                 strcmp(ifmt->name, last_name)>0){
 680                 name= ifmt->name;
 681                 long_name= ifmt->long_name;
 682                 encode=0;
 683             }
 684             if(name && strcmp(ifmt->name, name)==0)
 685                 decode=1;
 686         }
 687         if(name==NULL)
 688             break;
 689         last_name= name;
 690
 691         printf(
 692             " %s%s %-15s %s\n",
 693             decode ? "D":" ",
 694             encode ? "E":" ",
 695             name,
 696             long_name ? long_name:" ");
 697     }
 698 }
 699
 700 void show_codecs(void)
 701 {
 702     AVCodec *p=NULL, *p2;
 703     const char *last_name;
 704     printf(
 705         "Codecs:\n"
 706         " D..... = Decoding supported\n"
 707         " .E.... = Encoding supported\n"
 708         " ..V... = Video codec\n"
 709         " ..A... = Audio codec\n"
 710         " ..S... = Subtitle codec\n"
 711         " ...S.. = Supports draw_horiz_band\n"
 712         " ....D. = Supports direct rendering method 1\n"
 713         " .....T = Supports weird frame truncation\n"
 714         " ------\n");
 715     last_name= "000";
 716     for(;;){
 717         int decode=0;
 718         int encode=0;
 719         int cap=0;
 720         const char *type_str;
 721
 722         p2=NULL;
 723         while((p= av_codec_next(p))) {
 724             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 725                 strcmp(p->name, last_name)>0){
 726                 p2= p;
 727                 decode= encode= cap=0;
 728             }
 729             if(p2 && strcmp(p->name, p2->name)==0){
 730                 if(p->decode) decode=1;
 731                 if(p->encode) encode=1;
 732                 cap |= p->capabilities;
 733             }
 734         }
 735         if(p2==NULL)
 736             break;
 737         last_name= p2->name;
 738
 739         switch(p2->type) {
 740         case AVMEDIA_TYPE_VIDEO:
 741             type_str = "V";
 742             break;
 743         case AVMEDIA_TYPE_AUDIO:
 744             type_str = "A";
 745             break;
 746         case AVMEDIA_TYPE_SUBTITLE:
 747             type_str = "S";
 748             break;
 749         default:
 750             type_str = "?";
 751             break;
 752         }
 753         printf(
 754             " %s%s%s%s%s%s %-15s %s",
 755             decode ? "D": (/*p2->decoder ? "d":*/" "),
 756             encode ? "E":" ",
 757             type_str,
 758             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 759             cap & CODEC_CAP_DR1 ? "D":" ",
 760             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 761             p2->name,
 762             p2->long_name ? p2->long_name : "");
 763        /* if(p2->decoder && decode==0)
 764             printf(" use %s for decoding", p2->decoder->name);*/
 765         printf("\n");
 766     }
 767     printf("\n");
 768     printf(
 769 "Note, the names of encoders and decoders do not always match, so there are\n"
 770 "several cases where the above table shows encoder only or decoder only entries\n"
 771 "even though both encoding and decoding are supported. For example, the h263\n"
 772 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 773 "worse.\n");
 774 }
 775
 776 void show_bsfs(void)
 777 {
 778     AVBitStreamFilter *bsf=NULL;
 779
 780     printf("Bitstream filters:\n");
 781     while((bsf = av_bitstream_filter_next(bsf)))
 782         printf("%s\n", bsf->name);
 783     printf("\n");
 784 }
 785
 786 void show_protocols(void)
 787 {
 788     URLProtocol *up=NULL;
 789
 790     printf("Supported file protocols:\n"
 791            "I.. = Input  supported\n"
 792            ".O. = Output supported\n"
 793            "..S = Seek   supported\n"
 794            "FLAGS NAME\n"
 795            "----- \n");
 796     while((up = av_protocol_next(up)))
 797         printf("%c%c%c   %s\n",
 798                up->url_read  ? 'I' : '.',
 799                up->url_write ? 'O' : '.',
 800                up->url_seek  ? 'S' : '.',
 801                up->name);
 802 }
 803
 804 void show_filters(void)
 805 {
 806     AVFilter av_unused(**filter) = NULL;
 807
 808     printf("Filters:\n");
 809 #if CONFIG_AVFILTER
 810     while ((filter = av_filter_next(filter)) && *filter)
 811         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 812 #endif
 813 }
 814
 815 void show_pix_fmts(void)
 816 {
 817     enum PixelFormat pix_fmt;
 818
 819     printf(
 820         "Pixel formats:\n"
 821         "I.... = Supported Input  format for conversion\n"
 822         ".O... = Supported Output format for conversion\n"
 823         "..H.. = Hardware accelerated format\n"
 824         "...P. = Paletted format\n"
 825         "....B = Bitstream format\n"
 826         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 827         "-----\n");
 828
 829 #if !CONFIG_SWSCALE
 830 #   define sws_isSupportedInput(x)  0
 831 #   define sws_isSupportedOutput(x) 0
 832 #endif
 833
 834     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 835         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 836         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 837                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 838                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 839                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 840                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 841                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 842                pix_desc->name,
 843                pix_desc->nb_components,
 844                av_get_bits_per_pixel(pix_desc));
 845     }
 846 }
 847
 848 int read_yesno(void)
 849 {
 850     int c = getchar();
 851     int yesno = (toupper(c) == 'Y');
 852
 853     while (c != '\n' && c != EOF)
 854         c = getchar();
 855
 856     return yesno;
 857 }
 858
 859 int read_file(const char *filename, char **bufptr, size_t *size)
 860 {
 861     FILE *f = fopen(filename, "rb");
 862
 863     if (!f) {
 864         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 865         return AVERROR(errno);
 866     }
 867     fseek(f, 0, SEEK_END);
 868     *size = ftell(f);
 869     fseek(f, 0, SEEK_SET);
 870     *bufptr = av_malloc(*size + 1);
 871     if (!*bufptr) {
 872         fprintf(stderr, "Could not allocate file buffer\n");
 873         fclose(f);
 874         return AVERROR(ENOMEM);
 875     }
 876     fread(*bufptr, 1, *size, f);
 877     (*bufptr)[*size++] = '\0';
 878
 879     fclose(f);
 880     return 0;
 881 }
 882
 883 FILE *get_preset_file(char *filename, size_t filename_size,
 884                       const char *preset_name, int is_path, const char *codec_name)
 885 {
 886     FILE *f = NULL;
 887     int i;
 888     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 889                            getenv("HOME"),
 890                            FFMPEG_DATADIR,
 891                          };
 892
 893     if (is_path) {
 894         av_strlcpy(filename, preset_name, filename_size);
 895         f = fopen(filename, "r");
 896     } else {
 897 #ifdef _WIN32
 898         char datadir[MAX_PATH], *ls;
 899         base[2] = NULL;
 900
 901         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
 902         {
 903             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
 904                 if (*ls == '\\') *ls = '/';
 905
 906             if (ls = strrchr(datadir, '/'))
 907             {
 908                 *ls = 0;
 909                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
 910                 base[2] = datadir;
 911             }
 912         }
 913 #endif
 914         for (i = 0; i < 3 && !f; i++) {
 915             if (!base[i])
 916                 continue;
 917             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 918             f = fopen(filename, "r");
 919             if (!f && codec_name) {
 920                 snprintf(filename, filename_size,
 921                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 922                 f = fopen(filename, "r");
 923             }
 924         }
 925     }
 926
 927     return f;
 928 }