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