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