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