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 if (po->flags & OPT_FUNC2) {
 281                 if (po->u.func2_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             } else if (po->u.func_arg) {
 286                     po->u.func_arg(arg);
 287             }
 288             if(po->flags & OPT_EXIT)
 289                 exit(0);
 290         } else {
 291             if (parse_arg_function)
 292                 parse_arg_function(opt);
 293         }
 294     }
 295 }
 296
 297 int opt_default(const char *opt, const char *arg){
 298     int type;
 299     int ret= 0;
 300     const AVOption *o= NULL;
 301     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
 302
 303     for(type=0; *avcodec_opts && type<AVMEDIA_TYPE_NB && ret>= 0; type++){
 304         const AVOption *o2 = av_find_opt(avcodec_opts[0], opt, NULL, opt_types[type], opt_types[type]);
 305         if(o2)
 306             ret = av_set_string3(avcodec_opts[type], opt, arg, 1, &o);
 307     }
 308     if(!o && avformat_opts)
 309         ret = av_set_string3(avformat_opts, opt, arg, 1, &o);
 310     if(!o && sws_opts)
 311         ret = av_set_string3(sws_opts, opt, arg, 1, &o);
 312     if(!o){
 313         if (opt[0] == 'a' && avcodec_opts[AVMEDIA_TYPE_AUDIO])
 314             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_AUDIO], opt+1, arg, 1, &o);
 315         else if(opt[0] == 'v' && avcodec_opts[AVMEDIA_TYPE_VIDEO])
 316             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_VIDEO], opt+1, arg, 1, &o);
 317         else if(opt[0] == 's' && avcodec_opts[AVMEDIA_TYPE_SUBTITLE])
 318             ret = av_set_string3(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], opt+1, arg, 1, &o);
 319     }
 320     if (o && ret < 0) {
 321         fprintf(stderr, "Invalid value '%s' for option '%s'\n", arg, opt);
 322         exit(1);
 323     }
 324     if (!o) {
 325         AVCodec *p = NULL;
 326         AVOutputFormat *oformat = NULL;
 327         while ((p=av_codec_next(p))){
 328             AVClass *c= p->priv_class;
 329             if(c && av_find_opt(&c, opt, NULL, 0, 0))
 330                 break;
 331         }
 332         if (!p) {
 333             while ((oformat = av_oformat_next(oformat))) {
 334                 const AVClass *c = oformat->priv_class;
 335                 if (c && av_find_opt(&c, opt, NULL, 0, 0))
 336                     break;
 337             }
 338         }
 339         if(!p && !oformat){
 340             fprintf(stderr, "Unrecognized option '%s'\n", opt);
 341             exit(1);
 342         }
 343     }
 344
 345 //    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));
 346
 347     //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
 348     opt_values= av_realloc(opt_values, sizeof(void*)*(opt_name_count+1));
 349     opt_values[opt_name_count]= o ? NULL : av_strdup(arg);
 350     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
 351     opt_names[opt_name_count++]= o ? o->name : av_strdup(opt);
 352
 353     if ((*avcodec_opts && avcodec_opts[0]->debug) || (avformat_opts && avformat_opts->debug))
 354         av_log_set_level(AV_LOG_DEBUG);
 355     return 0;
 356 }
 357
 358 int opt_loglevel(const char *opt, const char *arg)
 359 {
 360     const struct { const char *name; int level; } log_levels[] = {
 361         { "quiet"  , AV_LOG_QUIET   },
 362         { "panic"  , AV_LOG_PANIC   },
 363         { "fatal"  , AV_LOG_FATAL   },
 364         { "error"  , AV_LOG_ERROR   },
 365         { "warning", AV_LOG_WARNING },
 366         { "info"   , AV_LOG_INFO    },
 367         { "verbose", AV_LOG_VERBOSE },
 368         { "debug"  , AV_LOG_DEBUG   },
 369     };
 370     char *tail;
 371     int level;
 372     int i;
 373
 374     for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
 375         if (!strcmp(log_levels[i].name, arg)) {
 376             av_log_set_level(log_levels[i].level);
 377             return 0;
 378         }
 379     }
 380
 381     level = strtol(arg, &tail, 10);
 382     if (*tail) {
 383         fprintf(stderr, "Invalid loglevel \"%s\". "
 384                         "Possible levels are numbers or:\n", arg);
 385         for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++)
 386             fprintf(stderr, "\"%s\"\n", log_levels[i].name);
 387         exit(1);
 388     }
 389     av_log_set_level(level);
 390     return 0;
 391 }
 392
 393 int opt_timelimit(const char *opt, const char *arg)
 394 {
 395 #if HAVE_SETRLIMIT
 396     int lim = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
 397     struct rlimit rl = { lim, lim + 1 };
 398     if (setrlimit(RLIMIT_CPU, &rl))
 399         perror("setrlimit");
 400 #else
 401     fprintf(stderr, "Warning: -%s not implemented on this OS\n", opt);
 402 #endif
 403     return 0;
 404 }
 405
 406 void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
 407 {
 408     int i;
 409     void *priv_ctx=NULL;
 410     if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
 411         AVCodecContext *avctx= ctx;
 412         if(codec && codec->priv_class && avctx->priv_data){
 413             priv_ctx= avctx->priv_data;
 414         }
 415     } else if (!strcmp("AVFormatContext", (*(AVClass**)ctx)->class_name)) {
 416         AVFormatContext *avctx = ctx;
 417         if (avctx->oformat && avctx->oformat->priv_class) {
 418             priv_ctx = avctx->priv_data;
 419         }
 420     }
 421
 422     for(i=0; i<opt_name_count; i++){
 423         char buf[256];
 424         const AVOption *opt;
 425         const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
 426         /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
 427         if(str && ((opt->flags & flags) == flags))
 428             av_set_string3(ctx, opt_names[i], str, 1, NULL);
 429         /* We need to use a differnt system to pass options to the private context because
 430            it is not known which codec and thus context kind that will be when parsing options
 431            we thus use opt_values directly instead of opts_ctx */
 432         if(!str && priv_ctx && av_get_string(priv_ctx, opt_names[i], &opt, buf, sizeof(buf))){
 433             av_set_string3(priv_ctx, opt_names[i], opt_values[i], 1, NULL);
 434         }
 435     }
 436 }
 437
 438 void print_error(const char *filename, int err)
 439 {
 440     char errbuf[128];
 441     const char *errbuf_ptr = errbuf;
 442
 443     if (av_strerror(err, errbuf, sizeof(errbuf)) < 0)
 444         errbuf_ptr = strerror(AVUNERROR(err));
 445     fprintf(stderr, "%s: %s\n", filename, errbuf_ptr);
 446 }
 447
 448 static int warned_cfg = 0;
 449
 450 #define INDENT        1
 451 #define SHOW_VERSION  2
 452 #define SHOW_CONFIG   4
 453
 454 #define PRINT_LIB_INFO(outstream,libname,LIBNAME,flags)                 \
 455     if (CONFIG_##LIBNAME) {                                             \
 456         const char *indent = flags & INDENT? "  " : "";                 \
 457         if (flags & SHOW_VERSION) {                                     \
 458             unsigned int version = libname##_version();                 \
 459             fprintf(outstream, "%slib%-9s %2d.%3d.%2d / %2d.%3d.%2d\n", \
 460                     indent, #libname,                                   \
 461                     LIB##LIBNAME##_VERSION_MAJOR,                       \
 462                     LIB##LIBNAME##_VERSION_MINOR,                       \
 463                     LIB##LIBNAME##_VERSION_MICRO,                       \
 464                     version >> 16, version >> 8 & 0xff, version & 0xff); \
 465         }                                                               \
 466         if (flags & SHOW_CONFIG) {                                      \
 467             const char *cfg = libname##_configuration();                \
 468             if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
 469                 if (!warned_cfg) {                                      \
 470                     fprintf(outstream,                                  \
 471                             "%sWARNING: library configuration mismatch\n", \
 472                             indent);                                    \
 473                     warned_cfg = 1;                                     \
 474                 }                                                       \
 475                 fprintf(stderr, "%s%-11s configuration: %s\n",          \
 476                         indent, #libname, cfg);                         \
 477             }                                                           \
 478         }                                                               \
 479     }                                                                   \
 480
 481 static void print_all_libs_info(FILE* outstream, int flags)
 482 {
 483     PRINT_LIB_INFO(outstream, avutil,   AVUTIL,   flags);
 484     PRINT_LIB_INFO(outstream, avcodec,  AVCODEC,  flags);
 485     PRINT_LIB_INFO(outstream, avformat, AVFORMAT, flags);
 486     PRINT_LIB_INFO(outstream, avdevice, AVDEVICE, flags);
 487     PRINT_LIB_INFO(outstream, avfilter, AVFILTER, flags);
 488     PRINT_LIB_INFO(outstream, swscale,  SWSCALE,  flags);
 489     PRINT_LIB_INFO(outstream, postproc, POSTPROC, flags);
 490 }
 491
 492 void show_banner(void)
 493 {
 494     fprintf(stderr, "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
 495             program_name, program_birth_year, this_year);
 496     fprintf(stderr, "  built on %s %s with %s %s\n",
 497             __DATE__, __TIME__, CC_TYPE, CC_VERSION);
 498     fprintf(stderr, "  configuration: " LIBAV_CONFIGURATION "\n");
 499     print_all_libs_info(stderr, INDENT|SHOW_CONFIG);
 500     print_all_libs_info(stderr, INDENT|SHOW_VERSION);
 501 }
 502
 503 void show_version(void) {
 504     printf("%s " LIBAV_VERSION "\n", program_name);
 505     print_all_libs_info(stdout, SHOW_VERSION);
 506 }
 507
 508 void show_license(void)
 509 {
 510     printf(
 511 #if CONFIG_NONFREE
 512     "This version of %s has nonfree parts compiled in.\n"
 513     "Therefore it is not legally redistributable.\n",
 514     program_name
 515 #elif CONFIG_GPLV3
 516     "%s is free software; you can redistribute it and/or modify\n"
 517     "it under the terms of the GNU General Public License as published by\n"
 518     "the Free Software Foundation; either version 3 of the License, or\n"
 519     "(at your option) any later version.\n"
 520     "\n"
 521     "%s is distributed in the hope that it will be useful,\n"
 522     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 523     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 524     "GNU General Public License for more details.\n"
 525     "\n"
 526     "You should have received a copy of the GNU General Public License\n"
 527     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 528     program_name, program_name, program_name
 529 #elif CONFIG_GPL
 530     "%s is free software; you can redistribute it and/or modify\n"
 531     "it under the terms of the GNU General Public License as published by\n"
 532     "the Free Software Foundation; either version 2 of the License, or\n"
 533     "(at your option) any later version.\n"
 534     "\n"
 535     "%s is distributed in the hope that it will be useful,\n"
 536     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 537     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 538     "GNU General Public License for more details.\n"
 539     "\n"
 540     "You should have received a copy of the GNU General Public License\n"
 541     "along with %s; if not, write to the Free Software\n"
 542     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 543     program_name, program_name, program_name
 544 #elif CONFIG_LGPLV3
 545     "%s is free software; you can redistribute it and/or modify\n"
 546     "it under the terms of the GNU Lesser General Public License as published by\n"
 547     "the Free Software Foundation; either version 3 of the License, or\n"
 548     "(at your option) any later version.\n"
 549     "\n"
 550     "%s is distributed in the hope that it will be useful,\n"
 551     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 552     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
 553     "GNU Lesser General Public License for more details.\n"
 554     "\n"
 555     "You should have received a copy of the GNU Lesser General Public License\n"
 556     "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 557     program_name, program_name, program_name
 558 #else
 559     "%s is free software; you can redistribute it and/or\n"
 560     "modify it under the terms of the GNU Lesser General Public\n"
 561     "License as published by the Free Software Foundation; either\n"
 562     "version 2.1 of the License, or (at your option) any later version.\n"
 563     "\n"
 564     "%s is distributed in the hope that it will be useful,\n"
 565     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
 566     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
 567     "Lesser General Public License for more details.\n"
 568     "\n"
 569     "You should have received a copy of the GNU Lesser General Public\n"
 570     "License along with %s; if not, write to the Free Software\n"
 571     "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 572     program_name, program_name, program_name
 573 #endif
 574     );
 575 }
 576
 577 void show_formats(void)
 578 {
 579     AVInputFormat *ifmt=NULL;
 580     AVOutputFormat *ofmt=NULL;
 581     const char *last_name;
 582
 583     printf(
 584         "File formats:\n"
 585         " D. = Demuxing supported\n"
 586         " .E = Muxing supported\n"
 587         " --\n");
 588     last_name= "000";
 589     for(;;){
 590         int decode=0;
 591         int encode=0;
 592         const char *name=NULL;
 593         const char *long_name=NULL;
 594
 595         while((ofmt= av_oformat_next(ofmt))) {
 596             if((name == NULL || strcmp(ofmt->name, name)<0) &&
 597                 strcmp(ofmt->name, last_name)>0){
 598                 name= ofmt->name;
 599                 long_name= ofmt->long_name;
 600                 encode=1;
 601             }
 602         }
 603         while((ifmt= av_iformat_next(ifmt))) {
 604             if((name == NULL || strcmp(ifmt->name, name)<0) &&
 605                 strcmp(ifmt->name, last_name)>0){
 606                 name= ifmt->name;
 607                 long_name= ifmt->long_name;
 608                 encode=0;
 609             }
 610             if(name && strcmp(ifmt->name, name)==0)
 611                 decode=1;
 612         }
 613         if(name==NULL)
 614             break;
 615         last_name= name;
 616
 617         printf(
 618             " %s%s %-15s %s\n",
 619             decode ? "D":" ",
 620             encode ? "E":" ",
 621             name,
 622             long_name ? long_name:" ");
 623     }
 624 }
 625
 626 void show_codecs(void)
 627 {
 628     AVCodec *p=NULL, *p2;
 629     const char *last_name;
 630     printf(
 631         "Codecs:\n"
 632         " D..... = Decoding supported\n"
 633         " .E.... = Encoding supported\n"
 634         " ..V... = Video codec\n"
 635         " ..A... = Audio codec\n"
 636         " ..S... = Subtitle codec\n"
 637         " ...S.. = Supports draw_horiz_band\n"
 638         " ....D. = Supports direct rendering method 1\n"
 639         " .....T = Supports weird frame truncation\n"
 640         " ------\n");
 641     last_name= "000";
 642     for(;;){
 643         int decode=0;
 644         int encode=0;
 645         int cap=0;
 646         const char *type_str;
 647
 648         p2=NULL;
 649         while((p= av_codec_next(p))) {
 650             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
 651                 strcmp(p->name, last_name)>0){
 652                 p2= p;
 653                 decode= encode= cap=0;
 654             }
 655             if(p2 && strcmp(p->name, p2->name)==0){
 656                 if(p->decode) decode=1;
 657                 if(p->encode) encode=1;
 658                 cap |= p->capabilities;
 659             }
 660         }
 661         if(p2==NULL)
 662             break;
 663         last_name= p2->name;
 664
 665         switch(p2->type) {
 666         case AVMEDIA_TYPE_VIDEO:
 667             type_str = "V";
 668             break;
 669         case AVMEDIA_TYPE_AUDIO:
 670             type_str = "A";
 671             break;
 672         case AVMEDIA_TYPE_SUBTITLE:
 673             type_str = "S";
 674             break;
 675         default:
 676             type_str = "?";
 677             break;
 678         }
 679         printf(
 680             " %s%s%s%s%s%s %-15s %s",
 681             decode ? "D": (/*p2->decoder ? "d":*/" "),
 682             encode ? "E":" ",
 683             type_str,
 684             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
 685             cap & CODEC_CAP_DR1 ? "D":" ",
 686             cap & CODEC_CAP_TRUNCATED ? "T":" ",
 687             p2->name,
 688             p2->long_name ? p2->long_name : "");
 689        /* if(p2->decoder && decode==0)
 690             printf(" use %s for decoding", p2->decoder->name);*/
 691         printf("\n");
 692     }
 693     printf("\n");
 694     printf(
 695 "Note, the names of encoders and decoders do not always match, so there are\n"
 696 "several cases where the above table shows encoder only or decoder only entries\n"
 697 "even though both encoding and decoding are supported. For example, the h263\n"
 698 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
 699 "worse.\n");
 700 }
 701
 702 void show_bsfs(void)
 703 {
 704     AVBitStreamFilter *bsf=NULL;
 705
 706     printf("Bitstream filters:\n");
 707     while((bsf = av_bitstream_filter_next(bsf)))
 708         printf("%s\n", bsf->name);
 709     printf("\n");
 710 }
 711
 712 void show_protocols(void)
 713 {
 714     void *opaque = NULL;
 715     const char *name;
 716
 717     printf("Supported file protocols:\n"
 718            "Input:\n");
 719     while ((name = avio_enum_protocols(&opaque, 0)))
 720         printf("%s\n", name);
 721     printf("Output:\n");
 722     while ((name = avio_enum_protocols(&opaque, 1)))
 723         printf("%s\n", name);
 724 }
 725
 726 void show_filters(void)
 727 {
 728     AVFilter av_unused(**filter) = NULL;
 729
 730     printf("Filters:\n");
 731 #if CONFIG_AVFILTER
 732     while ((filter = av_filter_next(filter)) && *filter)
 733         printf("%-16s %s\n", (*filter)->name, (*filter)->description);
 734 #endif
 735 }
 736
 737 void show_pix_fmts(void)
 738 {
 739     enum PixelFormat pix_fmt;
 740
 741     printf(
 742         "Pixel formats:\n"
 743         "I.... = Supported Input  format for conversion\n"
 744         ".O... = Supported Output format for conversion\n"
 745         "..H.. = Hardware accelerated format\n"
 746         "...P. = Paletted format\n"
 747         "....B = Bitstream format\n"
 748         "FLAGS NAME            NB_COMPONENTS BITS_PER_PIXEL\n"
 749         "-----\n");
 750
 751 #if !CONFIG_SWSCALE
 752 #   define sws_isSupportedInput(x)  0
 753 #   define sws_isSupportedOutput(x) 0
 754 #endif
 755
 756     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
 757         const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 758         printf("%c%c%c%c%c %-16s       %d            %2d\n",
 759                sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
 760                sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
 761                pix_desc->flags & PIX_FMT_HWACCEL   ? 'H' : '.',
 762                pix_desc->flags & PIX_FMT_PAL       ? 'P' : '.',
 763                pix_desc->flags & PIX_FMT_BITSTREAM ? 'B' : '.',
 764                pix_desc->name,
 765                pix_desc->nb_components,
 766                av_get_bits_per_pixel(pix_desc));
 767     }
 768 }
 769
 770 int read_yesno(void)
 771 {
 772     int c = getchar();
 773     int yesno = (toupper(c) == 'Y');
 774
 775     while (c != '\n' && c != EOF)
 776         c = getchar();
 777
 778     return yesno;
 779 }
 780
 781 int read_file(const char *filename, char **bufptr, size_t *size)
 782 {
 783     FILE *f = fopen(filename, "rb");
 784
 785     if (!f) {
 786         fprintf(stderr, "Cannot read file '%s': %s\n", filename, strerror(errno));
 787         return AVERROR(errno);
 788     }
 789     fseek(f, 0, SEEK_END);
 790     *size = ftell(f);
 791     fseek(f, 0, SEEK_SET);
 792     *bufptr = av_malloc(*size + 1);
 793     if (!*bufptr) {
 794         fprintf(stderr, "Could not allocate file buffer\n");
 795         fclose(f);
 796         return AVERROR(ENOMEM);
 797     }
 798     fread(*bufptr, 1, *size, f);
 799     (*bufptr)[*size++] = '\0';
 800
 801     fclose(f);
 802     return 0;
 803 }
 804
 805 void init_pts_correction(PtsCorrectionContext *ctx)
 806 {
 807     ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 808     ctx->last_pts = ctx->last_dts = INT64_MIN;
 809 }
 810
 811 int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
 812 {
 813     int64_t pts = AV_NOPTS_VALUE;
 814
 815     if (dts != AV_NOPTS_VALUE) {
 816         ctx->num_faulty_dts += dts <= ctx->last_dts;
 817         ctx->last_dts = dts;
 818     }
 819     if (reordered_pts != AV_NOPTS_VALUE) {
 820         ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 821         ctx->last_pts = reordered_pts;
 822     }
 823     if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 824        && reordered_pts != AV_NOPTS_VALUE)
 825         pts = reordered_pts;
 826     else
 827         pts = dts;
 828
 829     return pts;
 830 }
 831
 832 FILE *get_preset_file(char *filename, size_t filename_size,
 833                       const char *preset_name, int is_path, const char *codec_name)
 834 {
 835     FILE *f = NULL;
 836     int i;
 837     const char *base[3]= { getenv("FFMPEG_DATADIR"),
 838                            getenv("HOME"),
 839                            FFMPEG_DATADIR,
 840                          };
 841
 842     if (is_path) {
 843         av_strlcpy(filename, preset_name, filename_size);
 844         f = fopen(filename, "r");
 845     } else {
 846         for (i = 0; i < 3 && !f; i++) {
 847             if (!base[i])
 848                 continue;
 849             snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", preset_name);
 850             f = fopen(filename, "r");
 851             if (!f && codec_name) {
 852                 snprintf(filename, filename_size,
 853                          "%s%s/%s-%s.ffpreset", base[i],  i != 1 ? "" : "/.ffmpeg", codec_name, preset_name);
 854                 f = fopen(filename, "r");
 855             }
 856         }
 857     }
 858
 859     return f;
 860 }
 861
 862 #if CONFIG_AVFILTER
 863
 864 static int ffsink_init(AVFilterContext *ctx, const char *args, void *opaque)
 865 {
 866     FFSinkContext *priv = ctx->priv;
 867
 868     if (!opaque)
 869         return AVERROR(EINVAL);
 870     *priv = *(FFSinkContext *)opaque;
 871
 872     return 0;
 873 }
 874
 875 static void null_end_frame(AVFilterLink *inlink) { }
 876
 877 static int ffsink_query_formats(AVFilterContext *ctx)
 878 {
 879     FFSinkContext *priv = ctx->priv;
 880     enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE };
 881
 882     avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts));
 883     return 0;
 884 }
 885
 886 AVFilter ffsink = {
 887     .name      = "ffsink",
 888     .priv_size = sizeof(FFSinkContext),
 889     .init      = ffsink_init,
 890
 891     .query_formats = ffsink_query_formats,
 892
 893     .inputs    = (AVFilterPad[]) {{ .name          = "default",
 894                                     .type          = AVMEDIA_TYPE_VIDEO,
 895                                     .end_frame     = null_end_frame,
 896                                     .min_perms     = AV_PERM_READ, },
 897                                   { .name = NULL }},
 898     .outputs   = (AVFilterPad[]) {{ .name = NULL }},
 899 };
 900
 901 int get_filtered_video_frame(AVFilterContext *ctx, AVFrame *frame,
 902                              AVFilterBufferRef **picref_ptr, AVRational *tb)
 903 {
 904     int ret;
 905     AVFilterBufferRef *picref;
 906
 907     if ((ret = avfilter_request_frame(ctx->inputs[0])) < 0)
 908         return ret;
 909     if (!(picref = ctx->inputs[0]->cur_buf))
 910         return AVERROR(ENOENT);
 911     *picref_ptr = picref;
 912     ctx->inputs[0]->cur_buf = NULL;
 913     *tb = ctx->inputs[0]->time_base;
 914
 915     memcpy(frame->data,     picref->data,     sizeof(frame->data));
 916     memcpy(frame->linesize, picref->linesize, sizeof(frame->linesize));
 917     frame->interlaced_frame = picref->video->interlaced;
 918     frame->top_field_first  = picref->video->top_field_first;
 919     frame->key_frame        = picref->video->key_frame;
 920     frame->pict_type        = picref->video->pict_type;
 921
 922     return 1;
 923 }
 924
 925 #endif /* CONFIG_AVFILTER */