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