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