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, 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 //<<<<<<< HEAD
 392         fprintf(stderr, "Unrecognized option '%s'\n", opt);
 393         exit(1);
 394 /*||||||| merged common ancestors
 395         AVCodec *p = NULL;
 396         AVOutputFormat *oformat = NULL;
 397         while ((p=av_codec_next(p))){
 398             const AVClass *c = p->priv_class;
 399             if(c && av_find_opt(&c, opt, NULL, 0, 0))
 400                 break;
 401         }
 402         if (!p) {
 403             while ((oformat = av_oformat_next(oformat))) {
 404                 const AVClass *c = oformat->priv_class;
 405                 if (c && av_find_opt(&c, opt, NULL, 0, 0))
 406                     break;
 407             }
 408         }
 409         if(!p && !oformat){
 410             fprintf(stderr, "Unrecognized option '%s'\n", opt);
 411             exit(1);
 412         }
 413 =======
 414         AVCodec *p = NULL;
 415         AVOutputFormat *oformat = NULL;
 416         while ((p=av_codec_next(p))){
 417             const AVClass *c = p->priv_class;
 418             if(c && av_opt_find(&c, opt, NULL, 0, 0))
 419                 break;
 420         }
 421         if (!p) {
 422             while ((oformat = av_oformat_next(oformat))) {
 423                 const AVClass *c = oformat->priv_class;
 424                 if (c && av_opt_find(&c, opt, NULL, 0, 0))
 425                     break;
 426             }
 427         }
 428 >>>>>>> qatar/master*/
 429     }
 430
 431  out:
 432     if ((ret = opt_default2(opt, arg)) < 0)
 433         return ret;
 434
 435 //    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));
 436
 437     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 438     opt_values[opt_name_count] = av_strdup(arg);
 439     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 440     opt_names[opt_name_count++] = av_strdup(opt);
 441
 442     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 443         av_log_set_level(AV_LOG_DEBUG);
 444     return 0;
 445 }
 446
 447 int opt_loglevel(const char *opt, const char *arg)
 448 {
 449     const struct { const char *name; int level; } log_levels[] = {
 450         { "quiet"  , AV_LOG_QUIET   },
 451         { "panic"  , AV_LOG_PANIC   },
 452         { "fatal"  , AV_LOG_FATAL   },
 453         { "error"  , AV_LOG_ERROR   },
 454         { "warning", AV_LOG_WARNING },
 455         { "info"   , AV_LOG_INFO    },
 456         { "verbose", AV_LOG_VERBOSE },
 457         { "debug"  , AV_LOG_DEBUG   },
 458     };
 459     char *tail;
 460     int level;
 461     int i;
 462
 463     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 464         if (!strcmp(log_levels[i].name, arg)) {
 465             av_log_set_level(log_levels[i].level);
 466             return 0;
 467         }
 468     }
 469
 470     level = strtol(arg, &tail, 10);
 471     if (*tail) {
 472         fprintf(stderr, "Invalid loglevel \"%s\". "
 473                         "Possible levels are numbers or:\n", arg);
 474         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 475             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 476         exit(1);
 477     }
 478     av_log_set_level(level);
 479     return 0;
 480 }
 481
 482 int opt_timelimit(const char *opt, const char *arg)
 483 {
 484 #if HAVE_SETRLIMIT
 485     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 486     struct rlimit rl = { lim, lim + 1 };
 487     if (setrlimit(RLIMIT_CPU, &rl))
 488         perror("setrlimit");
 489 #else
 490     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 491 #endif
 492     return 0;
 493 }
 494
 495 static void *alloc_priv_context(int size, const AVClass *class)
 496 {
 497     void *p = av_mallocz(size);
 498     if (p) {
 499         *(const AVClass **)p = class;
 500         av_opt_set_defaults(p);
 501     }
 502     return p;
 503 }
 504
 505 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 506 {
 507     int i;
 508     void *priv_ctx=NULL;
 509     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 510         AVCodecContext *avctx= ctx;
 511         if(codec && codec->priv_class){
 512             if(!avctx->priv_data && codec->priv_data_size)
 513                 avctx->priv_data= alloc_priv_context(codec->priv_data_size, codec->priv_class);
 514             priv_ctx= avctx->priv_data;
 515         }
 516     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
 517         AVFormatContext *avctx = ctx;
 518         if (avctx->oformat && avctx->oformat->priv_class) {
 519             priv_ctx = avctx->priv_data;
 520         } else if (avctx->iformat && avctx->iformat->priv_class) {
 521             priv_ctx = avctx->priv_data;
 522         }
 523     }
 524
 525     for(i=0; i<opt_name_count; i++){
 526         char buf[256];
 527         const AVOption *opt;
 528         const char *str;
 529         if (priv_ctx) {
 530             if (av_find_opt(priv_ctx, opt_names[i], NULL, flags, flags)) {
 531                 if (av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL) < 0) {
 532                     fprintf(stderr, "Invalid value '%s' for option '%s'\n",
 533                             opt_names[i], opt_values[i]);
 534                     exit(1);
 535                 }
 536             } else
 537                 goto global;
 538         } else {
 539         global:
 540             str = av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 541             /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 542             if (str && ((opt->flags & flags) == flags))
 543                 av_set_string3(ctx, opt_names[i], str, 1, NULL);
 544         }
 545     }
 546 }
 547
 548 void print_error(const char *filename, int err)
 549 {
 550     char errbuf[128];
 551     const char *errbuf_ptr = errbuf;
 552
 553     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 554         errbuf_ptr = strerror(AVUNERROR(err));
 555     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 556 }
 557
 558 static int warned_cfg = 0;
 559
 560 #define INDENT        1
 561 #define SHOW_VERSION  2
 562 #define SHOW_CONFIG   4
 563
 564 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 565     if (CONFIG_##LIBNAME) {                                             \
 566         const char *indent = flags & INDENT? "  " : "";                 \
 567         if (flags & SHOW_VERSION) {                                     \
 568             unsigned int version = libname##_version();                 \
 569             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
 570                     indent, #libname,                                   \
 571                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 572                     LIB##LIBNAME##_VERSION_MINOR,                       \
 573                     LIB##LIBNAME##_VERSION_MICRO,                       \
 574                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 575         }                                                               \
 576         if (flags & SHOW_CONFIG) {                                      \
 577             const char *cfg = libname##_configuration();                \
 578             if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
 579                 if (!warned_cfg) {                                      \
 580                     fprintf(outstream,                                  \
 581                             "%sWARNING: library configuration mismatch\n", \
 582                             indent);                                    \
 583                     warned_cfg = 1;                                     \
 584                 }                                                       \
 585                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 586                         indent, #libname, cfg);                         \
 587             }                                                           \
 588         }                                                               \
 589     }                                                                   \
 590
 591 static void print_all_libs_info(FILE* outstream, int flags)
 592 {
 593     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 594     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 595     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 596     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 597     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 598     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 599     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 600 }
 601
 602 void show_banner(void)
 603 {
 604     fprintf(stderr, "%s version " FFMPEG_VERSION ", Copyright (c) %d-%d the FFmpeg developers\n",
 605             program_name, program_birth_year, this_year);
 606     fprintf(stderr, "  built on %s %s with %s %s\n",
 607             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 608     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
 609     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 610     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 611 }
 612
 613 void show_version(void) {
 614     printf("%s " FFMPEG_VERSION "\n", program_name);
 615     print_all_libs_info(stdout, SHOW_VERSION);
 616 }
 617
 618 void show_license(void)
 619 {
 620     printf(
 621 #if CONFIG_NONFREE
 622     "This version of %s has nonfree parts compiled in.\n"
 623     "Therefore it is not legally redistributable.\n",
 624     program_name
 625 #elif CONFIG_GPLV3
 626     "%s is free software; you can redistribute it and/or modify\n"
 627     "it under the terms of the GNU General Public License as published by\n"
 628     "the Free Software Foundation; either version 3 of the License, or\n"
 629     "(at your option) any later version.\n"
 630     "\n"
 631     "%s is distributed in the hope that it will be useful,\n"
 632     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 633     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 634     "GNU General Public License for more details.\n"
 635     "\n"
 636     "You should have received a copy of the GNU General Public License\n"
 637     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 638     program_name, program_name, program_name
 639 #elif CONFIG_GPL
 640     "%s is free software; you can redistribute it and/or modify\n"
 641     "it under the terms of the GNU General Public License as published by\n"
 642     "the Free Software Foundation; either version 2 of the License, or\n"
 643     "(at your option) any later version.\n"
 644     "\n"
 645     "%s is distributed in the hope that it will be useful,\n"
 646     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 647     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 648     "GNU General Public License for more details.\n"
 649     "\n"
 650     "You should have received a copy of the GNU General Public License\n"
 651     "along with %s; if not, write to the Free Software\n"
 652     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 653     program_name, program_name, program_name
 654 #elif CONFIG_LGPLV3
 655     "%s is free software; you can redistribute it and/or modify\n"
 656     "it under the terms of the GNU Lesser General Public License as published by\n"
 657     "the Free Software Foundation; either version 3 of the License, or\n"
 658     "(at your option) any later version.\n"
 659     "\n"
 660     "%s is distributed in the hope that it will be useful,\n"
 661     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 662     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 663     "GNU Lesser General Public License for more details.\n"
 664     "\n"
 665     "You should have received a copy of the GNU Lesser General Public License\n"
 666     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 667     program_name, program_name, program_name
 668 #else
 669     "%s is free software; you can redistribute it and/or\n"
 670     "modify it under the terms of the GNU Lesser General Public\n"
 671     "License as published by the Free Software Foundation; either\n"
 672     "version 2.1 of the License, or (at your option) any later version.\n"
 673     "\n"
 674     "%s is distributed in the hope that it will be useful,\n"
 675     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 676     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 677     "Lesser General Public License for more details.\n"
 678     "\n"
 679     "You should have received a copy of the GNU Lesser General Public\n"
 680     "License along with %s; if not, write to the Free Software\n"
 681     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 682     program_name, program_name, program_name
 683 #endif
 684     );
 685 }
 686
 687 void show_formats(void)
 688 {
 689     AVInputFormat *ifmt=NULL;
 690     AVOutputFormat *ofmt=NULL;
 691     const char *last_name;
 692
 693     printf(
 694         "File formats:\n"
 695         " D. = Demuxing supported\n"
 696         " .E = Muxing supported\n"
 697         " --\n");
 698     last_name= "000";
 699     for(;;){
 700         int decode=0;
 701         int encode=0;
 702         const char *name=NULL;
 703         const char *long_name=NULL;
 704
 705         while((ofmt= av_oformat_next(ofmt))) {
 706             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 707                 strcmp(ofmt->name, last_name)>0){
 708                 name= ofmt->name;
 709                 long_name= ofmt->long_name;
 710                 encode=1;
 711             }
 712         }
 713         while((ifmt= av_iformat_next(ifmt))) {
 714             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 715                 strcmp(ifmt->name, last_name)>0){
 716                 name= ifmt->name;
 717                 long_name= ifmt->long_name;
 718                 encode=0;
 719             }
 720             if(name && strcmp(ifmt->name, name)==0)
 721                 decode=1;
 722         }
 723         if(name==NULL)
 724             break;
 725         last_name= name;
 726
 727         printf(
 728             " %s%s %-15s %s\n",
 729             decode ? "D":" ",
 730             encode ? "E":" ",
 731             name,
 732             long_name ? long_name:" ");
 733     }
 734 }
 735
 736 void show_codecs(void)
 737 {
 738     AVCodec *p=NULL, *p2;
 739     const char *last_name;
 740     printf(
 741         "Codecs:\n"
 742         " D..... = Decoding supported\n"
 743         " .E.... = Encoding supported\n"
 744         " ..V... = Video codec\n"
 745         " ..A... = Audio codec\n"
 746         " ..S... = Subtitle codec\n"
 747         " ...S.. = Supports draw_horiz_band\n"
 748         " ....D. = Supports direct rendering method 1\n"
 749         " .....T = Supports weird frame truncation\n"
 750         " ------\n");
 751     last_name= "000";
 752     for(;;){
 753         int decode=0;
 754         int encode=0;
 755         int cap=0;
 756         const char *type_str;
 757
 758         p2=NULL;
 759         while((p= av_codec_next(p))) {
 760             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 761                 strcmp(p->name, last_name)>0){
 762                 p2= p;
 763                 decode= encode= cap=0;
 764             }
 765             if(p2 && strcmp(p->name, p2->name)==0){
 766                 if(p->decode) decode=1;
 767                 if(p->encode) encode=1;
 768                 cap |= p->capabilities;
 769             }
 770         }
 771         if(p2==NULL)
 772             break;
 773         last_name= p2->name;
 774
 775         switch(p2->type) {
 776         case AVMEDIA_TYPE_VIDEO:
 777             type_str = "V";
 778             break;
 779         case AVMEDIA_TYPE_AUDIO:
 780             type_str = "A";
 781             break;
 782         case AVMEDIA_TYPE_SUBTITLE:
 783             type_str = "S";
 784             break;
 785         default:
 786             type_str = "?";
 787             break;
 788         }
 789         printf(
 790             " %s%s%s%s%s%s %-15s %s",
 791             decode ? "D": (/*p2->decoder ? "d":*/" "),
 792             encode ? "E":" ",
 793             type_str,
 794             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 795             cap & CODEC_CAP_DR1 ? "D":" ",
 796             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 797             p2->name,
 798             p2->long_name ? p2->long_name : "");
 799        /* if(p2->decoder && decode==0)
 800             printf(" use %s for decoding", p2->decoder->name);*/
 801         printf("\n");
 802     }
 803     printf("\n");
 804     printf(
 805 "Note, the names of encoders and decoders do not always match, so there are\n"
 806 "several cases where the above table shows encoder only or decoder only entries\n"
 807 "even though both encoding and decoding are supported. For example, the h263\n"
 808 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 809 "worse.\n");
 810 }
 811
 812 void show_bsfs(void)
 813 {
 814     AVBitStreamFilter *bsf=NULL;
 815
 816     printf("Bitstream filters:\n");
 817     while((bsf = av_bitstream_filter_next(bsf)))
 818         printf("%s\n", bsf->name);
 819     printf("\n");
 820 }
 821
 822 void show_protocols(void)
 823 {
 824     URLProtocol *up=NULL;
 825
 826     printf("Supported file protocols:\n"
 827            "I.. = Input  supported\n"
 828            ".O. = Output supported\n"
 829            "..S = Seek   supported\n"
 830            "FLAGS NAME\n"
 831            "----- \n");
 832     while((up = av_protocol_next(up)))
 833         printf("%c%c%c   %s\n",
 834                up->url_read  ? 'I' : '.',
 835                up->url_write ? 'O' : '.',
 836                up->url_seek  ? 'S' : '.',
 837                up->name);
 838 }
 839
 840 void show_filters(void)
 841 {
 842     AVFilter av_unused(**filter) = NULL;
 843
 844     printf("Filters:\n");
 845 #if CONFIG_AVFILTER
 846     while ((filter = av_filter_next(filter)) && *filter)
 847         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 848 #endif
 849 }
 850
 851 void show_pix_fmts(void)
 852 {
 853     enum PixelFormat pix_fmt;
 854
 855     printf(
 856         "Pixel formats:\n"
 857         "I.... = Supported Input  format for conversion\n"
 858         ".O... = Supported Output format for conversion\n"
 859         "..H.. = Hardware accelerated format\n"
 860         "...P. = Paletted format\n"
 861         "....B = Bitstream format\n"
 862         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 863         "-----\n");
 864
 865 #if !CONFIG_SWSCALE
 866 #   define sws_isSupportedInput(x)  0
 867 #   define sws_isSupportedOutput(x) 0
 868 #endif
 869
 870     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 871         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 872         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 873                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 874                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 875                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 876                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 877                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 878                pix_desc->name,
 879                pix_desc->nb_components,
 880                av_get_bits_per_pixel(pix_desc));
 881     }
 882 }
 883
 884 int read_yesno(void)
 885 {
 886     int c = getchar();
 887     int yesno = (toupper(c) == 'Y');
 888
 889     while (c != '\n' && c != EOF)
 890         c = getchar();
 891
 892     return yesno;
 893 }
 894
 895 int read_file(const char *filename, char **bufptr, size_t *size)
 896 {
 897     FILE *f = fopen(filename, "rb");
 898
 899     if (!f) {
 900         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 901         return AVERROR(errno);
 902     }
 903     fseek(f, 0, SEEK_END);
 904     *size = ftell(f);
 905     fseek(f, 0, SEEK_SET);
 906     *bufptr = av_malloc(*size + 1);
 907     if (!*bufptr) {
 908         fprintf(stderr, "Could not allocate file buffer\n");
 909         fclose(f);
 910         return AVERROR(ENOMEM);
 911     }
 912     fread(*bufptr, 1, *size, f);
 913     (*bufptr)[*size++] = '\0';
 914
 915     fclose(f);
 916     return 0;
 917 }
 918
 919 FILE *get_preset_file(char *filename, size_t filename_size,
 920                       const char *preset_name, int is_path, const char *codec_name)
 921 {
 922     FILE *f = NULL;
 923     int i;
 924     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 925                            getenv("HOME"),
 926                            FFMPEG_DATADIR,
 927                          };
 928
 929     if (is_path) {
 930         av_strlcpy(filename, preset_name, filename_size);
 931         f = fopen(filename, "r");
 932     } else {
 933 #ifdef _WIN32
 934         char datadir[MAX_PATH], *ls;
 935         base[2] = NULL;
 936
 937         if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
 938         {
 939             for (ls = datadir; ls < datadir + strlen(datadir); ls++)
 940                 if (*ls == '\\') *ls = '/';
 941
 942             if (ls = strrchr(datadir, '/'))
 943             {
 944                 *ls = 0;
 945                 strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
 946                 base[2] = datadir;
 947             }
 948         }
 949 #endif
 950         for (i = 0; i < 3 && !f; i++) {
 951             if (!base[i])
 952                 continue;
 953             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 954             f = fopen(filename, "r");
 955             if (!f && codec_name) {
 956                 snprintf(filename, filename_size,
 957                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 958                 f = fopen(filename, "r");
 959             }
 960         }
 961     }
 962
 963     return f;
 964 }
 965
 966 #if CONFIG_AVFILTER
 967
 968 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 969 {
 970     FFSinkContext *priv = ctx->priv;
 971
 972     if (!opaque)
 973         return AVERROR(EINVAL);
 974     *priv = *(FFSinkContext *)opaque;
 975
 976     return 0;
 977 }
 978
 979 static void null_end_frame(AVFilterLink *inlink) { }
 980
 981 static int ffsink_query_formats(AVFilterContext *ctx)
 982 {
 983     FFSinkContext *priv = ctx->priv;
 984     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
 985
 986     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
 987     return 0;
 988 }
 989
 990 AVFilter ffsink = {
 991     .name      = "ffsink",
 992     .priv_size = sizeof(FFSinkContext),
 993     .init      = ffsink_init,
 994
 995     .query_formats = ffsink_query_formats,
 996
 997     .inputs    = (AVFilterPad[]) {{ .name          = "default",
 998                                     .type          = AVMEDIA_TYPE_VIDEO,
 999                                     .end_frame     = null_end_frame,
1000                                     .min_perms     = AV_PERM_READ, },
1001                                   { .name = NULL }},
1002     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
1003 };
1004
1005 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
1006                              AVFilterBufferRef **picref_ptr, AVRational *tb)
1007 {
1008     int ret;
1009     AVFilterBufferRef *picref;
1010     *picref_ptr = NULL;
1011
1012     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
1013         return ret;
1014     if (!(picref = ctx->inputs[0]->cur_buf))
1015         return AVERROR(ENOENT);
1016     *picref_ptr = picref;
1017     ctx->inputs[0]->cur_buf = NULL;
1018     *tb = ctx->inputs[0]->time_base;
1019
1020     memcpy(frame->data,     picref->data,     sizeof(frame->data));
1021     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
1022     frame->pkt_pos          = picref->pos;
1023     frame->interlaced_frame = picref->video->interlaced;
1024     frame->top_field_first  = picref->video->top_field_first;
1025     frame->key_frame        = picref->video->key_frame;
1026     frame->pict_type        = picref->video->pict_type;
1027     frame->sample_aspect_ratio = picref->video->sample_aspect_ratio;
1028
1029     return 1;
1030 }
1031
1032 #endif /* CONFIG_AVFILTER */